perm filename PUP6[AP,DBL]2 blob
sn#118066 filedate 1974-09-05 generic text, type T, neo UTF8
(FILECREATED " 5-SEP-74 02:24:22" PUP6.;4 372904
changes to: LISTFILES PREADLIST GETCODE PREDICATE:RESOLVE:DECISION:KNOWLEDGE LONG:NAME:DEMON LONG:TAG START
previous date: " 4-SEP-74 12:06:40" PUP6.;3)
(LISPXPRINT (QUOTE PUP6COMS)
T)
(RPAQQ PUP6COMS
((FNS * PUP6FNS)
$ ADAPTATION:DEFER:DECISION:KNOWLEDGE ADAPTATION:RESOLVE:DECISION:KNOWLEDGE ADJECTIVES AFFECTS:ALL
AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE ALPHORDER ALTERNATIVES:DEFER:DECISION:KNOWLEDGE
ALTERNATIVES:RESOLVE:DECISION:KNOWLEDGE AND:LOOP:TERMINATION:KNOWLEDGE APPLIED:SO:AS:TO:KEEP ARG1 ARG1 ARG1
ASSERT:LISTS BEING BOOLEAN:DEFER:DECISION:KNOWLEDGE BOOLEAN:RESOLVE:DECISION:KNOWLEDGE BOTH:RESULTS
BREAKUP:LIST CALL COMEVAL COMMENT COMPILABLE:BEING:PARTS DEFINITION:DEFER:DECISION:KNOWLEDGE
DEFINITION:RESOLVE:DECISION:KNOWLEDGE DICHOTOMY:DEFER:DECISION:KNOWLEDGE DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE
DOES DOESNT DUMMY:ARGUMENT EQUAL EQUALS EVAL EVAL:BEING:PARTS EXPERTAG EXPERTISE FALSE FAST:BEING:LIST
FAST:COMPLEX FAST:FUNCTION:LIST FINAL:PREADLIST FLOW:ASSIGNMENT FOREVER FUNDAMENTAL:IDEN:TABLE GI:DIALOG
GLOBAL:CONTEXT:0 GO HOLDX INFERIOR ING IS IS:BEING:LIST ISNT KNOWLEDGE LABEL:COUNTER LEFT:SIDE
LIST:VALUE:SETUP LONG:TAG MINOR:WORDS NAME NEW:P:NUMBER NO:RESULTS NON:EVAL:BEING:PARTS NON:EXECUTABLE
NOT:TIME:YET ONETYPE ONETYPE:DEFER:DECISION:KNOWLEDGE ONETYPE:RESOLVE:DECISION:KNOWLEDGE PARTS
PERMANENT:KNOWN:NAMES POSSIBLE PREADLIST PREDICATE:DEFER:DECISION:KNOWLEDGE
PREDICATE:RESOLVE:DECISION:KNOWLEDGE PRIMITIVE:PROGRAMS:LIST PRIMITIVE:VARS:LIST PROGRAM:WRITING:PHASES
PROPERTY:LIST:SETUP RESULT:COUNTER RESULTS RIGHT:SIDE SET:OF SET:OF:BEING:PARTS SET:OF:BEINGS SINCE SNAP
SNAPFNS SNAPVARS SOMEOF:DEFER:DECISION:KNOWLEDGE SOMEOF:RESOLVE:DECISION:KNOWLEDGE STICKY:BNAME STICKY:BPART
SUBSETOF:DEFER:DECISION:KNOWLEDGE SUBSETOF:RESOLVE:DECISION:KNOWLEDGE SUPERIOR TASK:TYPE TRIVIAL:BEING:LIST
TRIVIAL:DEMON:LIST UNKNOWN UNTIL WHEN:ALL WHEN:ALL:DEFER:DECISION:KNOWLEDGE YES YES:RESULTS YESNO YESNO:TAG
(COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS)))
(P (MAPC (APPEND PUP6FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ NOLINKFNS T)
(SETQ #RPARS NIL)
(DWIM)
(PRIN1 "
DWIM DISABLED. TO GET AUTOMATIC EDITF FROM SOURCE, TYPE DWIM(T)
")
(CHANGESLICE 6)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(WIDEPAPER T))
(P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PUPRIN1 " MINI PUP FILE; USE FAD OR AD OR MAKEFILE "))
(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS (ADDVARS (NLAMA VECTOR TUPLE STRUCTURE CSORT
COMMENT CLASS)
(NLAML FORSOME)))))
(RPAQQ PUP6FNS
(@ A:BEING:ORDER A:BEING:WHEN AD AD1 ADD:BEING ADD:EFFECTS ADD:IDEN ALLSUBSTS ANTI:RULE ANTIRULE ASSERTIONS
ATOMP ATTENTION:DEMONS BREAK:PREADLIST CAAR:ORDER CAR:ORDER CHANGEB CHANGEP CHECK:COMMENTS CLASS COLON:BACK
COLON:BREAK COMMENT COMPATIBLE CSORT DEFERRAL:DEMON DETERMINE:ALL:ARG2:VALUES DETERMINE:ALL:ARG3:VALUES
DETERMINE:ALL:ARG:VALUES DETERMINE:ARG2:VALUE DETERMINE:ARG3:VALUE DETERMINE:ARG:VALUE DIMENSION1
DIMENSION2 DIMENSION3 DISK:DUMP DOT:PROD DUMMIES DUMP:BEING ECONOMY:DEMON ELIM:COMMON:HEAD ELIM:COMMON:TAIL
ENTER EVALUATE:AFFECT EVEN:ALT FAD FAST FAST:A:BEING:ORDER FAST:BEING:COMPLEX FAST:COMPILE FAST:PREAD
FIND:AND:TAG FIND:INSIDE FIRST:FEW FIRSTN FLATTEN FLOW:PRECEDED FOREVER FORGETFUL:USER:DEMON FORGOT:ANY
FORSOME FRINGE:OF:CONCIOUSNESS:DEMON GET:USAGE GETCODE HEAD HIGHLY:STRUCTURED IDIOM:DEMON
IMPROBABILITY:COMPLEX INCOMMENT INFER:INSIDE INFERENCE:DEMONS INITIALS INSERT:PRINT:STATEMENTS INSIDE
INSTANTIATE INTUPLE INVECTOR IRRELEVANT JPL LEARN:BY:EXAMPLE LIST:JOIN LIST:TRANSLATE LISTFILES
LOCATE:AFFECTED:AREA LOCATION:TRANSLATE LONG:NAME:DEMON LUMP:ASSERTIONS MAD MAIN:WORDS MAKE:SPECIFIC MATCH
MERGE:IN MERGE:IN2 MINIMUM MINTERSECTION MOST:GENERAL MOVE:BEING MULT:INTERSECTION NEW:IDEN NEW:LEVEL
NOT:YET:INITIALIZED NULLIFY NUMBER:SUBST ODD:ALT OPPOSITE OUTFORM OUTNIL OUTQUOTE OUTTUPLE OUTVECTOR PBT
PBTV PERMIT:DETAILED:DECISION PERMIT:USER:INTERRUPT PLISTMATCH PLURAL POP:DEMONS PREAD PREDICT:AFFECT PREPL
PRET PROCEDURE:INTERSECTION PROCEDURE:PULLOUT PROCEDURE:SUBSET PROCESS:USER:INTERRUPT
PROGRAM:WRITING:DEMONS PSYCHOLOGY:DEMON PULLOUT PULLOUT1 PUPP PUPRETTYPRINT PUPRIN1 PUPRINT PUSH:DEMONS
RANDOMSELECT REINVESTIGATION:DEMON RELEVANT REMOVE:EFFECTS REMOVE:IDEN RFAST SELECT:STRUCTURE:TYPE
SEMI:COMPILE SET:UP:EFFECTS:TABLE SET:UP:IDEN:TABLE SETDIFFERENCE SETINTERSECTION SETUNION SINGLETON
SINGULAR SIZE SNAPSHOT SPECIFICITY:CHECK:DEMON START STRUCTURE STRUCTURE:COMPATIBLE
STRUCTURE:INDUCING:DEMON SUBALLEVELS SUBSTITUTE SWITCHFAST SWITCHFN TEMPORARILY TRACE:COMPILE TRUE:MINIMUM
TRY:TO:SATISFY TUPLE UNGERUNDIFY USER:INTERRUPT:AT:ADAPTING USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END USER:INTERRUPT:AT:PHASES VECTOR VECTOR:AVERAGE VECTOR:SUM
WHEN:VALUE Z@))
(DEFINEQ
(@
(LAMBDA (E)
E))
(A:BEING:ORDER
(LAMBDA (B1 B2)
(LESSP (GETP B1 FAST:COMPLEX)
(GETP B2 FAST:COMPLEX))))
(A:BEING:WHEN
(LAMBDA (BB SUM)
(SETQ SUM 0)
(MAPC (GETP BB WHEN)
(FUNCTION (LAMBDA (W)
(COND
((EVAL (CAR W))
(SETQ SUM (PLUS SUM (EVAL (CADR W)))))))))
SUM))
(AD
(LAMBDA (L)
(AD1 L)
(MAKEFILE (QUOTE PUP6))))
(AD1
(LAMBDA (L RP6)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP6FNS (SORT (APPEND PUP6FNS L)))
(SETQ PUP6FNS (INTERSECTION PUP6FNS PUP6FNS))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(REMPROP X SPEC:WHY))))
(SETQ SET:OF:BEINGS (SORT (APPEND SET:OF:BEINGS)))
(SETQ RP6 (REVERSE (CDR PUP6COMS)))
(SETQ PUP6COMS (APPEND (QUOTE ((FNS * PUP6FNS)))
(SORT (APPEND (CDDDDR RP6)))
(LIST (CADDDR RP6)
(CADDR RP6)
(CADR RP6)
(CAR RP6))))))
(ADD:BEING
(LAMBDA (B TREAD)
(SET B B)
(PUT B BEING T)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(PUPRIN1 X)
(PUPRIN1 " ")
(COND
((SETQ TREAD (PREAD))
(PUT B X TREAD))))))
(PUT B FAST:COMPLEX (CAR (NLSETQ (FAST:BEING:COMPLEX B))))
(PUPRIN1 "*** FINISHED ***
SHOULD I MAKE A NEW FILE OF PUP? (T OR NIL)..... ")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SEMI:COMPILE B)
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER WRITE:PROGRAM PUP6FNS)
(COND
((PREAD)
(AD (LIST B)))
(T (SETQ PUP6FNS (CONS B PUP6FNS))
T)))
((PREAD)
(AD NIL))
((LENGTH PUP6FNS)))))
(ADD:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (APPEND (GETP B MAIN:EFFECTS)))
(SETQ EFFECTS:TABLE (APPEND EFFECTS:TABLE TEMPG))
(SORT EFFECTS:TABLE CAAR:ORDER)))
(ADD:IDEN
(LAMBDA (B)
(SETQ TEMPG (APPEND (GETP B IDEN)))
(SETQ IDEN:TABLE (APPEND IDEN:TABLE TEMPG))
(SORT IDEN:TABLE CAAR:ORDER)))
(ALLSUBSTS
(LAMBDA (NEW OLD L E B FLIST)
(SETQ B NIL)
(SETQ E L)
(PROG NIL
LABEL4
(COND
((HEAD OLD E)
(SETQ FLIST (CONS (APPEND B NEW (NTH E (ADD1 (LENGTH OLD))))
FLIST))))
(SETQ B (NCONC1 B (CAR E)))
(SETQ E (CDR E))
(COND
(E (GO LABEL4))))
FLIST))
(ANTI:RULE
(LAMBDA (R)
(LIST (CADR R)
(CAR R))))
(ANTIRULE
(LAMBDA (R)
(LIST (CADR R)
(CAR R))))
(ASSERTIONS
(LAMBDA (TEMPA)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SETQ TEMPA (CONS (LIST L (EVAL L))
TEMPA)))))
TEMPA))
(ATOMP
(LAMBDA (SOMETHING)
(ATOM SOMETHING)))
(ATTENTION:DEMONS
(LAMBDA NIL T))
(BREAK:PREADLIST
(LAMBDA (N)
(SETQ FINAL:PREADLIST (NTH OLD:PREADLIST N))
(SETQ OLD:PREADLIST (FIRSTN (SUB1 N)
OLD:PREADLIST))
(PUPRIN1 OLD:PREADLIST)
(PUPRIN1 " *** ")
(PUPRIN1 FINAL:PREADLIST)
(LENGTH FINAL:PREADLIST)))
(CAAR:ORDER
(LAMBDA (O1 O2)
(CAR:ORDER (CAR O1)
(CAR O2))))
(CAR:ORDER
(LAMBDA (O1 O2)
(COND
(O1 (COND
(O2 (COND
((EQUAL (CAR O1)
(CAR O2))
(CAR:ORDER (CDR O1)
(CDR O2)))
((ATOM (CAR O1))
(ALPHORDER (CAR O1)
(CAR O2)))
((ATOM (CAR O2))
NIL)
(T (CAR:ORDER (CAR O1)
(CAR O2)))))
(T NIL)))
(T T))))
(CHANGEB
(LAMBDA (B:NAME B:PART TEMP)
(COND
((MEMBER B:NAME IS:BEING:LIST)
(SETQ STICKY:BNAME B:NAME))
(T (SETQ B:PART B:NAME)
(PUPRINT (SETQ B:NAME STICKY:BNAME))))
(COND
((MEMBER B:PART SET:OF:BEING:PARTS)
(SETQ STICKY:BPART B:PART))
(B:PART (PUPRIN1 "
I ASSUME YOU MADE AN ERROR
")
(ERROR!))
(T (PUPRINT (SETQ B:PART STICKY:BPART))))
(SETQ TEMP (GETP B:NAME B:PART))
(EDITV TEMP)
(COND
((EQUAL B:PART MAIN:EFFECTS)
(REMOVE:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(REMOVE:IDEN B:NAME)))
(PUT B:NAME B:PART TEMP)
(COND
((MEMBER B:PART COMPILABLE:BEING:PARTS)
(SEMI:COMPILE B:NAME)))
(COND
((NULL TEMP)
(REMPROP B:NAME B:PART))
((EQUAL B:PART MAIN:EFFECTS)
(ADD:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(ADD:IDEN B:NAME)))
T))
(CHANGEP
(LAMBDA (P X)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ X (GETP B P))
(PUPRINT B)
(COND
((ATOM X)
(PUPRIN1 "SORRY, PART IS NIL. NEW PART ....... ")
(SETQ X (PREAD)))
(T (EDITV X)))
(PUT B P X))))))
(CHECK:COMMENTS
(LAMBDA (FORM)
(COND
((NOT (LISTP FORM))
FORM)
((EQUAL (CAR FORM)
COMMENT)
(INCOMMENT FORM))
(T (MAPCAR FORM CHECK:COMMENTS)))))
(CLASS
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1))))))))
(COLON:BACK
(LAMBDA (LL MM)
(SETQ MM (CAR LL))
(SETQ LL (MAPCAR (CDR LL)
(FUNCTION (LAMBDA (E)
(CONCAT ":" E)))))
(SETQ LL (CONS MM LL))
(PACK LL)))
(COLON:BREAK
(LAMBDA (E)
(PROG (UP RP BUFF)
(SETQ UP (UNPACK E))
(SETQ BUFF NIL)
LL (COND
((NULL UP)
(SETQ RP (CONS (PACK BUFF)
RP))
(RETURN (REVERSE RP))))
(COND
((MEMBER (CAR UP)
BREAKUP:LIST)
(SETQ RP (CONS (PACK BUFF)
RP))
(SETQ BUFF NIL))
(T (SETQ BUFF (NCONC1 BUFF (CAR UP)))))
(SETQ UP (CDR UP))
(GO LL))))
(COMMENT
(NLAMBDA FORM
(CONS COMMENT (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((NOT (LISTP F1))
F1)
(T (EVAL F1)))))))))
(COMPATIBLE
(LAMBDA (A B)
T))
(CSORT
(NLAMBDA X
(MAPC X (FUNCTION (LAMBDA (L)
(SET L (SORT (APPEND (EVAL L)))))))))
(DEFERRAL:DEMON
(LAMBDA NIL
(MAPCAR UNDEFERRED:DECISION:LIST DEFER:DECISION)
T))
(DETERMINE:ALL:ARG2:VALUES
(LAMBDA NIL NIL))
(DETERMINE:ALL:ARG3:VALUES
(LAMBDA NIL NIL))
(DETERMINE:ALL:ARG:VALUES
(LAMBDA NIL NIL))
(DETERMINE:ARG2:VALUE
(LAMBDA (CHOICE1 ENT2 HOLD:ANY2)
(SETQ ARG2 UNKNOWN)
(SETQ ENT2 (CADDR (SASSOC (CADR CHOICE1)
TRUE:FN:CALL:LIST)))
(COND
((NULL ENT2)
(SOME TRUE:FN:CALL:LIST (FUNCTION (LAMBDA (TF)
(COND
((MATCH (TUPLE FRAG1 ANY2 ANY1 (CADR CHOICE1))
TF)
(SETQ ENT2 (PACK (LIST (QUOTE AN:ELEMENT:OF:)
ANY1))))))))))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY2 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED
IN (CADR CHOICE1))
TOL)
(SETQ ARG2 ANY2))))))
(COND
((EQUAL ARG2 UNKNOWN)
(SETQ ARG2 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG2))
(SETQ HOLD:ANY2 UNKNOWN)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE1)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG2)
((EQUAL ARG2 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG2))))
(DETERMINE:ARG3:VALUE
(LAMBDA (CHOICE1 ENT2 HOLD:ANY2)
(SETQ ARG3 UNKNOWN)
(SETQ ENT2 (CADDDR (SASSOC (CADR CHOICE1)
TRUE:FN:CALL:LIST)))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED
IN (CADR CHOICE1))
TOL)
(SETQ ARG3 ANY1))))))
(COND
((EQUAL ARG3 UNKNOWN)
(SETQ ARG3 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG3))
(SETQ HOLD:ANY2 UNKNOWN)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE1)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG3)
((EQUAL ARG3 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG3))))
(DETERMINE:ARG:VALUE
(LAMBDA (CHOICE1 ENT2 HOLD:ANY2)
(SETQ ARG1 UNKNOWN)
(SETQ ENT2 (CADR (SASSOC (CADR CHOICE1)
TRUE:FN:CALL:LIST)))
(COND
((NULL ENT2)
(SOME TRUE:FN:CALL:LIST (FUNCTION (LAMBDA (TF)
(COND
((MATCH (TUPLE FRAG1 ANY1 ANY2 (CADR CHOICE1))
TF)
(SETQ ENT2 ANY1))))))))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED
IN (CADR CHOICE1))
TOL)
(SETQ ARG1 ANY1))))))
(COND
((EQUAL ARG1 UNKNOWN)
(SETQ ARG1 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG1))
(SETQ HOLD:ANY2 UNKNOWN)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE1)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG1)
((EQUAL ARG1 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG1))))
(DIMENSION1
(LAMBDA (B)
(EVAL (CAR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION2
(LAMBDA (B)
(EVAL (CADR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION3
(LAMBDA (B)
(EVAL (CADDR (GETP B COMPLEXITY:VECTOR)))))
(DISK:DUMP
(LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE)))
(DOT:PROD
(LAMBDA (L1 L2)
(COND
(L1 (PLUS (COND
(L2 (TIMES (CAR L1)
(CAR L2)))
(T 0.0))
(DOT:PROD (CDR L1)
(CDR L2))))
(T 0))))
(DUMMIES
(LAMBDA (NDUM)
(COND
((ZEROP NDUM)
NIL)
(T (CONS (COLON:BACK (LIST DUMMY:ARGUMENT NDUM))
(DUMMIES (SUB1 NDUM)))))))
(DUMP:BEING
(LAMBDA (B X2)
(PRIN1 "************************* ")
(PRINT B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(COND
((SETQ X2 (GETP B X))
(PRINT X)
(COND
((ATOM X2)
(PRINT X2))
(T (PP X2)))
(TERPRI))))))
(QUOTE FINISHED)))
(ECONOMY:DEMON
(LAMBDA NIL
(SETQ AWARE:PUP:LIST NIL)
(SETQ PUP:SATISFIED:LIST NIL)
(SETQ READ:USER:LIST NIL)
(SETQ RESOLVED:DECISION:LIST (LIST (CAR RESOLVED:DECISION:LIST)))
(SETQ TRANSLATED:PAIR:LIST NIL)
(SETQ DOING:PUP:LIST (FIRSTN 2 DOING:PUP:LIST))
(SETQ TRANSLATED:INFO:LIST (FIRSTN 2 TRANSLATED:INFO:LIST))
(SETQ PUP:STUDIED:LIST (LIST (CAR PUP:STUDIED:LIST)))))
(ELIM:COMMON:HEAD
(LAMBDA (A B NA NB)
(COND
((AND A B (EQUAL (CAR A)
(CAR B)))
(ELIM:COMMON:HEAD (CDR A)
(CDR B)
NA NB))
(T (SET NA A)
(SET NB B)))))
(ELIM:COMMON:TAIL
(LAMBDA (A B NA NB)
(ELIM:COMMON:HEAD (REVERSE A)
(REVERSE B)
NA NB)
(SET NA (REVERSE (EVAL NA)))
(SET NB (REVERSE (EVAL NB)))))
(ENTER
(LAMBDA (EXPERTISE)
(SETQ NEW:F:NUMBER 0)
(SETQ NEW:P:NUMBER 0)
(SETQ RESULT:COUNTER 0)
(SETQ LABEL:COUNTER 0)
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(REMPROP B P))))
(REMPROP B BEING)
(SET B UNKNOWN))))
(MAPC TRIVIAL:BEING:LIST (FUNCTION (LAMBDA (TB)
(PUT TB BEING T)
(SET TB TB))))
(SETQ IS:BEING:LIST SET:OF:BEINGS)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(COND
((NULL (GETP B P))
(REMPROP B P)))))))))
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(COND
((AND (COND
((EQUAL (CAR (QUOTE OLD:PREADLIST))
(QUOTE NOBIND))
(PUPRIN1 " *** DANGER: OLD:PREADLIST UNASSIGNED.
WHAT IS IT (THIS WILL BE EVALLED) ? USER: ")
(EVAL (READ)))
(T T))
OLD:PREADLIST
(PRIN1 "
I CAN GUESS ALL YOUR ANSWERS FOR A WHILE; SHOULD I? ")
(MEMBER (READ)
(TUPLE Y YES MAYBE)))
(SETQ PREADLIST (SUBST YESNO:TAG YESNO (COPY OLD:PREADLIST))))
(T (SETQ PREADLIST NIL)))
(START EXPERTISE)
(PUPRIN1 "
EXITING FROM THE SYSTEM.
")))
(EVALUATE:AFFECT
(LAMBDA (I B E1 E2 F1 S1)
(SETQ E1 (OUTVECTOR (CADR (MEMBER (QUOTE INSTEADOF)
I))))
(SETQ E2 (OUTVECTOR (CADDR (CADR (LDIFF I (MEMBER (QUOTE INSTEADOF)
I))))))
(SETQ F1 (INSIDE E1 (LAST (GETP B META:CODE))))
(SETQ S1 (SUBST E2 E1 (COPY F1)))
(PUT B META:CODE (SUBST S1 F1 (COPY (GETP B META:CODE))))
(SEMI:COMPILE B)
(PUPRIN1 (CONCAT "
THE NEW METACODE FOR BEING " B " IS AS FOLLOWS: " (GETP B META:CODE)))))
(EVEN:ALT
(LAMBDA (L)
(COND
(L (COND
((EQUAL (CAAR L)
(QUOTE NOBIND))
(SET (CAR L)
(CAR L))))
(CONS (CAR L)
(ODD:ALT (CDR L)))))))
(FAD
(LAMBDA (L TEMP5)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP6FNS (SORT (COPY (APPEND PUP6FNS L IS:BEING:LIST))))
(SETQ PUP6FNS (INTERSECTION PUP6FNS PUP6FNS))
(SETQ TEMP5 PUP6VARS)
(SETQ PUP6VARS (REVERSE (CONS (QUOTE (P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PUPRIN1 " MINI PUP FILE; USE FAD OR AD OR MAKEFILE ")))
(APPEND (CDR (REVERSE PUP6VARS))
ASSERT:LISTS))))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(SETQ SET:OF:BEINGS (SORT (APPEND SET:OF:BEINGS)))
(SETQ RP6 (REVERSE PUP6VARS))
(SETQ PUP6VARS (APPEND (SORT (APPEND (CDDDDR RP6)))
(LIST (CADDDR RP6)
(CADDR RP6)
(CADR RP6)
(CAR RP6))))
(RPLACA (QUOTE PUP6COMS)
(QUOTE NOBIND))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(REMPROP B (QUOTE EXPR)))))
(SETQ EXPERTISE T)
(COND
((PERMIT:USER:INTERRUPT)
(MAKEFILE (QUOTE PUP6)
(QUOTE C))))
(SETQ PUP6VARS TEMP5)
(SETQ PUP6FNS (SETDIFFERENCE PUP6FNS IS:BEING:LIST))
T))
(FAST
(LAMBDA (SPEED)
(MAPC FAST:BEING:LIST SWITCHFAST)
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(PUT B FAST:COMPLEX (FAST:BEING:COMPLEX B)))))
(MAPC FAST:FUNCTION:LIST SWITCHFN)))
(FAST:A:BEING:ORDER
(LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2))))
(FAST:BEING:COMPLEX
(LAMBDA (B)
(COND
((NOT (ATOM B))
(SETQ B (CAR B))))
(COND
((GETP B COMPLEXITY:VECTOR)
(DOT:PROD (QUOTE (.01 .06 .03 0.0 .9))
(MAPCAR (GETP B COMPLEXITY:VECTOR)
EVAL)))
(T 1.0))))
(FAST:COMPILE
(LAMBDA NIL
(SETQ STRF T)
(MAPC (LIST UTILIZE WHEN:NEXT SATISFY GET:NAME TRANSLATE CHOOSE:FROM)
(FUNCTION (LAMBDA (B)
(COMPILE1 B (GETD B)))))))
(FAST:PREAD
(LAMBDA (T82 T83 T84)
(COND
(PREADLIST
(SETQ T82 (CAR PREADLIST))
(SETQ PREADLIST (CDR PREADLIST))
(COND
((EQUAL (SETQ T83 (READ))
T82)
T82)
((PRIN1
(CONCAT
"
HMMM. I DON'T LIKE THAT TOO MUCH. HOW ABOUT THIS REPLY INSTEAD:
" T82 "
TYPE YES IF THIS IS OK, TYPE ] IF I MUST RETAIN YOUR (UGHH) ANSWER,
OR TYPE IN A NEW ANSWER TO ME
USER: "))
(SELECTQ (SETQ T84 (READ))
(YES T82)
(NIL T83)
T84))))
(T (READ)))))
(FIND:AND:TAG
(LAMBDA (TARGET STUFF)
(COND
((NOT (LISTP STUFF))
(LIST STUFF))
((MEMBER (CAR STUFF)
(COMMENT QUOTE STRUCTURE))
(LIST STUFF))
((MATCH TARGET STUFF)
(SETQ NTAG2 T)
(LIST STUFF "***TAG***"))
((LIST (MAPCONC STUFF (FUNCTION (LAMBDA (STU)
(FIND:AND:TAG TARGET STU)))))))))
(FIND:INSIDE
(LAMBDA (E)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(COND
((INSIDE E (CDR B))
(PRINT B))))))
(MAPC PUP6COMS (FUNCTION (LAMBDA (C)
(AND (ATOM C)
(NOT (EQUAL (QUOTE NOBIND)
(CAR C)))
(INSIDE E (EVAL C))
(PRINT C)))))
(MAPC PUP6FNS (FUNCTION (LAMBDA (F)
(COND
((INSIDE E (GETD F))
(PRINT F))))))))
(FIRST:FEW
(LAMBDA (L N)
(SETQ N (PLUS 1 (IQUOTIENT (LENGTH L)
2)))
(REVERSE (NTH (REVERSE L)
N))))
(FIRSTN
(LAMBDA (N L)
(PROG (TTT)
LLL (COND
((ZEROP N)
(RETURN TTT)))
(SETQ N (SUB1 N))
(SETQ TTT (NCONC1 TTT (CAR L)))
(SETQ L (CDR L))
(GO LLL))))
(FLATTEN
(LAMBDA (L)
(COND
((NOT (LISTP L))
(LIST L))
(T (APPEND (FLATTEN (CAR L))
(FLATTEN (CDR L)))))))
(FLOW:PRECEDED
(LAMBDA (FORM)
(PUPRIN1 "
FLOW:PRECEDED ISNT IN YET.
")
(PUPRIN1 "LOOK AT ARGUMENT AND ANSWER T OR NIL:
")
(PUPRINT FORM)
(PUPRIN1 "
(THIS WOULD NORMALLY BE DONE BY SYSTEM, NOT BY USER .... ")
(PREAD)))
(FOREVER
(LAMBDA NIL NIL))
(FORGETFUL:USER:DEMON
(LAMBDA NIL
(SETQ AWARE:USER:LIST (SETUNION FRINGE:CONCIOUS:LIST (LIST (CAR AWARE:USER:LIST))))
T))
(FORGOT:ANY
(LAMBDA NIL
(MAPATOMS (FUNCTION (LAMBDA (X)
(AND (EXPRP X)
(NOT (OR (MEMBER X PUP6FNS)
(MEMBER X IS:BEING:LIST)
(MEMBER X PUP6VARS)))
(PRINT X)))))))
(FORSOME
(NLAMBDA (X IN XSET ACTION)
(PROG (ESET EE)
(SETQ ESET (EVAL XSET))
LABELL
(COND
((NULL ESET)
(RETURN NIL)))
(SET X (CAR ESET))
(SETQ ESET (CDR ESET))
(COND
((EVAL ACTION))
(T (GO LABELL))))))
(FRINGE:OF:CONCIOUSNESS:DEMON
(LAMBDA NIL T))
(GET:USAGE
(LAMBDA (SP GEN HANY2 HFRAG1 GUR)
(SETQ HANY2 ANY2)
(SETQ ANY2 NIL)
(SETQ HFRAG1 FRAG1)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(MATCH (VECTOR (@ SP)
TYPE OF (LIST VECTOR GEN)
IS FRAG1 USED
IN ANY2)
TOL))))
(SETQ GUR ANY2)
(SETQ ANY2 HANY2)
(SETQ FRAG1 HFRAG1)
GUR))
(GETCODE
(LAMBDA (F1 FNAME LEVEL C1 C2 OLDNAME:TAG C11 F1BACKUP)
(COND
((EQUAL (CAR (QUOTE ARG:LIST))
(QUOTE NOBIND))
(SETQQ ARG:LIST (ARG1 ARG2 ARG3))))
(COND
((NOT (LISTP F1))
(COND
((MEMBER F1 ARG:LIST)
(SETQ FARGS (NCONC1 FARGS F1))
F1)
((MEMBER F1 PRIMITIVE:PROGRAMS:LIST)
F1)
((MEMBER F1 TRIVIAL:BEING:LIST)
F1)
((NOT (GETP F1 BEING))
(COND
((OR (NOT (MINUSP LEVEL))
(AND (MATCH (TUPLE A R G ANY1)
(UNPACK F1))))
(SETQ FARGS (NCONC1 FARGS F1))))
F1)
((MEMBER F1 (LIST ARG1 (SETQ PS1 (PACK (TUPLE POSSIBLE:(@ ARG1))))
(PACK (TUPLE SET:OF:(PLURAL PS1)))))
F1)
((MEMBER F1 (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS))
F1)
((MEMBER F1 IS:STRUCTURE:LIST)
F1)
(T (SETQ F1BACKUP F1)
(GET:NAME (LIST VECTOR F1)
(VECTOR CNAME))
(COND
((NULL OLDNAME:TAG)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR F1BACKUP)
IS UNKNOWN BUT USED
IN (@ FNAME))
TYPE:OF:LIST))
(SETQ UNDEFINED:SECTION:LIST (SETUNION UNDEFINED:SECTION:LIST (LIST (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR
F1BACKUP)))))
)
(T (SETQ OLDNAME:TAG NIL)))
CNAME)))
((EVAL (GETP (CAR F1)
FORM:CHANGING)))
((MEMBER (CAR F1)
(QUOTE (COMMENT QUOTE NLAMBDA * STRUCTURE)))
F1)
((MATCH (TUPLE SETQ ANY1 ANY2)
F1)
(SETQ C1 ANY2)
(SETQ C11 ANY1)
(COND
((OR (NOT (OR (GETP C11 BEING)
(EQUAL TASK (VECTOR CONCEPT:FORMATION))))
(NUMBERP (CAR (LAST (COLON:BREAK C11))))
(MATCH (TUPLE A R G FRAG1)
(UNPACK C11))
(MEMBER C11 ARG:LIST)
(MEMBER C11 (LIST ARG1 (SETQ PS1 (PACK (TUPLE POSSIBLE:(@ ARG1))))
(PACK (TUPLE SET:OF:(PLURAL PS1)))
(QUOTE SET:OF:POSSIBLE:NAMES:OF:CLASS)))
(MEMBER C11 PRIMITIVE:PROGRAMS:LIST)
(EQUAL (QUOTE SYSTEM)
(CAR (LAST (COLON:BREAK C11))))
(MATCH (TUPLE E V A L : A R G FRAG1)
(UNPACK C11)))
(SETQ CNAME C11))
(T (GET:NAME (LIST VECTOR C11)
(VECTOR CNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR C11)
IS USED
IN (VECTOR ASSIGNMENT STATEMENT IN (@ FNAME)))
TYPE:OF:LIST))
(TUPLE SETQ (@ CNAME)
(GETCODE C1 FNAME (SUB1 LEVEL))))
(T (CONS (PROG1 (SETQ C1 (GETCODE (CAR F1)
FNAME
(SUB1 LEVEL)))
(COND
((AND OLDNAME:TAG (SETQ VTCODE (GETP C1 META:CODE))
(EQUAL (CAR VTCODE)
(QUOTE PROGN)))
(PUT C1 META:CODE (APPEND (TUPLE PROGN (COMMENT IN SOME CALLS, ARG1 WAS INSTANTIATED
AS (CADR F1)))
(CDR VTCODE))))))
(PROG1 (SETQ C2 (GETCODE (CDR F1)
(COND
((MEMBER C1 PRIMITIVE:PROGRAMS:LIST)
FNAME)
((GETP C1 BEING)
C1)
(T FNAME))
(SUB1 LEVEL)))
(COND
((AND (ATOM C1)
(NUMBERP (CAR (LAST (COLON:BREAK C1)))))
(SETQ TRUE:FN:CALL:LIST (CONS (OUTVECTOR (CONS C1 C2))
TRUE:FN:CALL:LIST))))))))))
(HEAD
(LAMBDA (L1 L2)
(COND
(L1 (AND (EQUAL (CAR L1)
(CAR L2))
(HEAD (CDR L1)
(CDR L2))))
(T T))))
(HIGHLY:STRUCTURED
(LAMBDA (B)
(EQUAL (CAR (GETP B META:CODE))
STRUCTURE)))
(IDIOM:DEMON
(LAMBDA NIL T))
(IMPROBABILITY:COMPLEX
(LAMBDA (L)
(COND
((NUMBERP (CAR L)))
(650))))
(INCOMMENT
(LAMBDA (L)
(COND
((NOT (LISTP L))
L)
((EQUAL (CAR L)
COMMENT)
(MAPCAR L INCOMMENT))
((EQUAL (CAR L)
COMEVAL)
(MAPCAR (CDR L)
INCOMMENT))
(T (CONS COMMENT (MAPCAR L INCOMMENT))))))
(INFER:INSIDE
(LAMBDA (SUBROUTINE FN:NAME)
T))
(INFERENCE:DEMONS
(LAMBDA NIL T))
(INITIALS
(LAMBDA (L)
(MAPCAR L (FUNCTION (LAMBDA (E)
(CAR (UNPACK E)))))))
(INSERT:PRINT:STATEMENTS
(LAMBDA NIL
(PUPRIN1 " SORRY, I AM INSERTING THE PRINT STATMENTS BY OMNISCIENCE ")
(SELECTQ TASK:NAME
(GI:1 (PUT (QUOTE PAD:4)
META:CODE
(SUBST (QUOTE (AND (FOREACH NAME IN SET:OF:POSSIBLE:NAMES:OF:CLASS
DO (PROGN (PUPRINT NAME)
(PUPRINT (EVAL (PACK (TUPLE SET:OF:(@ NAME):STRINGS))))
(TERPRI)
T))
(PROGN (TERPRI)
(PUPRINT (QUOTE SET:OF:RULES))
(PUPRINT SET:OF:RULES)
T)
(GO LABEL:1)))
(QUOTE (GO LABEL:1))
(COPY (GETP PAD:4 META:CODE)))))
(CF:1 (PUT PAD:2 META:CODE (SUBST (QUOTE (AND (FOREACH NAME IN SET:OF:POSSIBLE:NAMES:OF:CLASS
DO (PROGN (PUPRINT NAME)
(COND
((GETP NAME CLASS:OBJECTS:33)
(PUPRIN1 "OBJECTS ")
(PUPRINT (GETP NAME CLASS:OBJECTS:33))))
(COND
((GETP NAME CLASS:YES:RELNS:35)
(PUPRIN1 "MUST HAVE ")
(PUPRINT (GETP NAME CLASS:YES:RELNS:35))))
(COND
((GETP NAME CLASS:NO:RELNS:36)
(PUPRIN1 "MUSNT HAVE ")
(PUPRINT (GETP NAME CLASS:NO:RELNS:36))))
(COND
((GETP NAME CLASS:MAYBE:RELNS:37)
(PUPRIN1 "MAY HAVE ")
(PUPRINT (GETP NAME CLASS:MAYBE:RELNS:37))))
(TERPRI)
T))
(GO LABEL:1)))
(QUOTE (GO LABEL:1))
(COPY (GETP PAD:2 META:CODE))))
(SETQ GLOBAL:INITIALIZATION:LIST (CONS (TUPLE SETQ TYPE:OF:C:F CLASSIFICATORY:CONCEPT:FORMATION)
GLOBAL:INITIALIZATION:LIST)))
(AIR:1 (SETQ INS (CAR (SOME IS:BEING:LIST (FUNCTION (LAMBDA (B)
(MEMBER CONDITIONAL:INSERTION (GETP B GENERALIZATIONS)))))))
(SETQ DEL (CAR (SOME IS:BEING:LIST (FUNCTION (LAMBDA (B)
(MEMBER CONDITIONAL:DELETION (GETP B GENERALIZATIONS)))))))
(SETQ EXA (CAR (SOME IS:BEING:LIST (FUNCTION (LAMBDA (B)
(MEMBER EXAMINE:STRUCTURE (GETP B GENERALIZATIONS)))))))
(SETQ MER (INSIDE MERGE:IN (GETD INS)))
(SETQ MER2 (CADR MER))
(SETQ NMER2 (LIST PUPRINT MER2))
(SETQ NMER (SUBST NMER2 MER2 (COPY MER)))
(PUT INS META:CODE (SUBST NMER MER (COPY (GETP INS META:CODE))))
(SEMI:COMPILE INS)
(SETQ MER (INSIDE PULLOUT (GETD DEL)))
(SETQ MER2 (CADR MER))
(SETQ NMER2 (LIST PUPRINT MER2))
(SETQ NMER (SUBST NMER2 MER2 (COPY MER)))
(PUT DEL META:CODE (SUBST NMER MER (COPY (GETP DEL META:CODE))))
(SEMI:COMPILE DEL))
(PUPRIN1 " I DON'T RECOGNIZE THE TASK "))))
(INSIDE
(LAMBDA (E L)
(COND
((ATOM L)
NIL)
((MEMBER E L)
(SETQ INSIDE:RESULT L))
((SOME L (FUNCTION (LAMBDA (L1)
(INSIDE E L1))))
INSIDE:RESULT))))
(INSTANTIATE
(LAMBDA (FORM)
(COND
((ATOM FORM)
FORM)
((STRINGP FORM)
FORM)
((EQUAL (CAR FORM)
$)
(EVAL (CADR FORM)))
(T (CONS (INSTANTIATE (CAR FORM))
(INSTANTIATE (CDR FORM)))))))
(INTUPLE
(LAMBDA (L)
(COND
((NOT (LISTP L))
L)
((EQUAL (CAR L)
TUPLE)
(MAPCAR L INTUPLE))
(T (CONS TUPLE (MAPCAR L INTUPLE))))))
(INVECTOR
(LAMBDA (L)
(COND
((NOT (LISTP L))
L)
((EQUAL (CAR L)
VECTOR)
(MAPCAR L INVECTOR))
(T (CONS VECTOR (MAPCAR L INVECTOR))))))
(IRRELEVANT
(LAMBDA (L)
(NOT (EVAL (CDR L)))))
(JPL
(LAMBDA NIL
(SETQ OLD:PREADLIST (APPEND OLD:PREADLIST FINAL:PREADLIST))))
(LEARN:BY:EXAMPLE
(LAMBDA (ARGVECTOR)
(PUPRIN1 "
LEARN BY EXAMPLE IS NOT IN YET; PLEASE TYPE IN WHAT IT SHOULD RETURN.
ITS ARGUMENT VECTOR IS ")
(PUPRIN1 ARGVECTOR)
(PUPRIN1 " . OK, TYPE IN ANSWER:
USER: ")
(INVECTOR (PREAD))))
(LIST:JOIN
(LAMBDA (LL FL AL)
(COND
((AND LL (ATOM (CAR LL))
(LISTP (CAR FL)))
(LIST:JOIN AL (CONS LL FL)
NIL))
(LL (LIST:JOIN (CDR LL)
(COND
((ATOM (CAR LL))
(NCONC1 FL (CAR LL)))
((OR (NULL FL)
(LISTP (CAR FL)))
(CONS (CAR LL)
FL))
((LISTP (CAR LL))
(APPEND FL (CAR LL)))
(T FL))
AL))
(AL (LIST:JOIN AL FL NIL))
(T FL))))
(LIST:TRANSLATE
(LAMBDA (A B)
(COND
((MEMBER A (TUPLE (VECTOR ARG1)
(VECTOR ARG2)
(VECTOR ARG3)))
(CADR A))
((LISTP A)
(TRANSLATE A B))
(T A))))
(LISTFILES
(LAMBDA (X)
(COND
((NULL X)
(PRIN1 " NO MORE FILES TO LIST JUST NOW "))
((ATOM X)
(SETQ X (LIST X))))
(PRIN1 "
SUPPRESSION OF FILE LISTING ")
(MAPC X (FUNCTION (LAMBDA (X1)
(PRIN1 (CONCAT "
SHOULD I FTP THE FILE " X1 " OVER TO SAIL? "))
(COND
((MEMBER (READ)
(QUOTE (Y YES MAYBE)))
(TENEX (CONCAT "FTP
SAIL
LOG AP,DBL
SEND " X1 "≠
" X1 "
DISC
QUIT
")))))))))
(LOCATE:AFFECTED:AREA
(LAMBDA (I)
(CAR (SOME IS:BEING:LIST (FUNCTION (LAMBDA (B)
(INSIDE (CADADR I)
(GETP B WHY))))))))
(LOCATION:TRANSLATE
(LAMBDA (LLL P1 P2 P3 VERB)
(SETQ P3 (CAR (SETINTERSECTION (TUPLE BEFORE AFTER)
LLL)))
(SETQ LLL (PULLOUT P3 LLL))
(SETQ VERB (UNGERUNDIFY (CAR LLL)))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((AND (MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR VERB)
IS FRAG1 USED
IN ANY2)
TOL)
(COMPATIBLE (CDR (SETQ P1 (SASSOC ANY1 TRUE:FN:CALL:LIST)))
(CDR LLL)))
(SETQ P2 (CAR (OUTVECTOR ANY2))))))))
(LIST P1 P2 P3)))
(LONG:NAME:DEMON
(LAMBDA (MLIST UPT LNAME)
(COND
(LONG:TAG (SETQ MLIST (MAPCONC (FLATTEN CODING:WARNING:LIST)
(FUNCTION (LAMBDA (SS)
(COND
((GREATERP (LENGTH (SETQ UPT (UNPACK SS)))
50)
(LIST SS)))))))
(MAPC (INTERSECTION MLIST MLIST)
(FUNCTION (LAMBDA (TOL)
(SETQQ LNAME LNAME)
(GET:NAME (VECTOR (COLON:BACK (REVERSE (CDR (REVERSE (COLON:BREAK TOL))))))
(VECTOR LNAME))
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (AL)
(SET AL (DSUBST LNAME TOL (EVAL AL))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND
((GETP B META:CODE)
(PUT B META:CODE (DSUBST LNAME TOL (GETP B META:CODE)))))))))))))))
(LUMP:ASSERTIONS
(LAMBDA (L TEMPL TEMPL2)
(SETQ TEMPL NIL)
(SETQ L (ASSERTIONS))
(MAPC L (FUNCTION (LAMBDA (L1)
(SETQ TEMPL (APPEND TEMPL (CADR L1))))))
(SETQ TEMPL2 (COPY TEMPL))
(SETQ TEMPL2 (INTERSECTION TEMPL2 TEMPL2))
(SORT TEMPL2)))
(MAD
(LAMBDA (L TEMP5)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP6FNS (SORT (APPEND PUP6FNS L)))
(RPLACA (QUOTE PUP6COMS)
(QUOTE NOBIND))
(SETQ PUP6FNS (INTERSECTION PUP6FNS PUP6FNS))
(SETQ PUP6FNS (SETDIFFERENCE PUP6FNS SET:OF:BEINGS))
(SETQ TEMP5 PUP6VARS)
(SETQ PUP6VARS (REVERSE (CONS (QUOTE (P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PUPRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP6VARS)))))
(SETQ PUP6VARS (SETDIFFERENCE PUP6VARS ASSERT:LISTS))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP6))
(SETQ PUP6VARS TEMP5)
(SETQ PUP6FNS (APPEND SET:OF:BEINGS PUP6FNS))
T))
(MAIN:WORDS
(LAMBDA (L)
(SETDIFFERENCE L MINOR:WORDS)))
(MAKE:SPECIFIC
(LAMBDA (A)
(SETQ IS:SPECIFIC:LIST (CONS A IS:SPECIFIC:LIST))))
(MATCH
(LAMBDA (A B LD)
(SETQ LD (ADD1 (DIFFERENCE (LENGTH B)
(LENGTH A))))
(SETQ MATCH:RESULT T)
(COND
((MINUSP LD)
(SETQ MATCH:RESULT NIL))
(T (MAPC A (FUNCTION (LAMBDA (A1)
(COND
((MEMB A1 (QUOTE (ANY1 ANY2 ANY3)))
(SET A1 (CAR B))
(SETQ B (CDR B)))
((MEMB A1 (QUOTE (FRAG1 FRAG2)))
(SET A1 (FIRSTN LD B))
(SETQ B (NTH B (ADD1 LD))))
((EQUAL A1 (CAR B))
(SETQ B (CDR B)))
((LISTP A1)
(SETQ MATCH:RESULT (AND MATCH:RESULT (MATCH A1 (CAR B))))
(SETQ B (CDR B)))
(T (SETQ MATCH:RESULT NIL))))))))
(AND (NULL B)
MATCH:RESULT)))
(MERGE:IN
(LAMBDA (E L F)
(COND
((MEMBER E L)
L)
((AND (LISTP E)
(LISTP (CAR E)))
(MERGE:IN2 E L F))
((NULL L)
(LIST E))
((APPLY* F E (CAR L))
(CONS E L))
(T (CONS (CAR L)
(MERGE:IN E (CDR L)
F))))))
(MERGE:IN2
(LAMBDA (E L F)
(COND
(E (MERGE:IN (CAR E)
(MERGE:IN2 (CDR E)
L F)
F))
(T L))))
(MINIMUM
(LAMBDA (L F MINV MIN TV ELE NEWNUM MINNUM LHOLD MN MNTEMP)
(SETQ MNTEMP 1)
(SETQ MN 1)
(SETQ LHOLD L)
(SETQ L (OUTVECTOR L))
(SETQ MIN (CAR L))
(SETQ MINV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ MINNUM UNKNOWN)
(CADAR (CDDDDR MIN))))))
(MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(SETQ MNTEMP (ADD1 MNTEMP))
(COND
((OR (LESSP (SETQ TV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ NEWNUM UNKNOWN)
(CADAR (CDDDDR ELE))))))
MINV)
(AND (EQUAL TV MINV)
(OR (AND (NUMBERP NEWNUM)
(NOT (NUMBERP MINNUM)))
(AND (NUMBERP NEWNUM)
(NUMBERP MINNUM)
(LESSP NEWNUM MINNUM)))))
(SETQ MIN ELE)
(SETQ MN MNTEMP)
(SETQ MINNUM NEWNUM)
(SETQ MINV TV))))))
(CAR (NTH LHOLD MN))))
(MINTERSECTION
(LAMBDA (LL)
(COND
((ATOM LL)
NIL)
((EQUAL (LENGTH LL)
1)
(CAR LL))
(T (INTERSECTION (CAR LL)
(MINTERSECTION (CDR LL)))))))
(MOST:GENERAL
(LAMBDA (L)
(COND
((NUMBERP (CAR (LAST (COLON:BREAK (CAR L)))))
(CAR L))
((NUMBERP (CAR (LAST (COLON:BREAK (CADR L)))))
(CADR L))
(T (CAR L)))))
(MOVE:BEING
(LAMBDA (B:OLD B)
(SET B B)
(PUT B BEING T)
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(PUT B FAST:COMPLEX (COPY (GETP B:OLD FAST:COMPLEX)))
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(PUT B P (COPY (SUBST B B:OLD (COPY (GETP B:OLD P))))))))
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER ENCODE PUP6FNS)
(SETQ PUP6FNS (CONS B PUP6FNS))))
(SEMI:COMPILE B)))
(MULT:INTERSECTION
(LAMBDA (L)
(COND
((CDDR L)
(SETINTERSECTION (CAR L)
(MULT:INTERSECTION (CDR L))))
(T (SETINTERSECTION (CAR L)
(CADR L))))))
(NEW:IDEN
(LAMBDA NIL
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(PUT B IDEN (LIST (LIST (QUOTE AND)
(LIST (QUOTE EQUAL)
(QUOTE (CAR LI))
B)
(LIST (QUOTE EQUAL)
(QUOTE (LENGTH (CDR LI)))
(LENGTH (GETP B EXPLICIT:ARGS))))
(LIST (QUOTE LIST)
B
(LIST TRANSLATE (QUOTE (CADR LI)))))))))))
(NEW:LEVEL
(LAMBDA (EXPERTISE)
(PROG (NEWL)
L2 (COND
(EXPERTISE (PUPRIN1 "USER INTERRUPT LEVEL... "))
(T
(PUPRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L (SETQ NEWL (COND
((NUMBERP EXPERTISE))
((PREAD))))
(SETQ EXPERTISE NIL)
(SETQ PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ
NEWL
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND
(PUPRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS))))
(NOT:YET:INITIALIZED
(LAMBDA (ARGU)
(PUPRIN1 "
NOT:YET:INITIALIZED ISNT IN YET. LOOK AT ARG AND ANSWER T OR NIL...
")
(PUPRINT ARGU)
(PREAD)))
(NULLIFY
(LAMBDA (L)
(SET (CAR L)
NIL)
(COND
((CDR L)
(NULLIFY (CDR L))))))
(NUMBER:SUBST
(LAMBDA (NEW OLD FORM)
(COND
(FORM (CONS (COND
((EQUAL (CAR FORM) OLD)
NEW)
((NUMBERP (CAR FORM))
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER)))
((CAR FORM)))
(NUMBER:SUBST NEW OLD (CDR FORM)))))))
(ODD:ALT
(LAMBDA (L)
(COND
(L (COND
((EQUAL (CAAR L)
(QUOTE NOBIND))
(SET (CAR L)
(CAR L))))
(EVEN:ALT (CDR L))))))
(OPPOSITE
(LAMBDA (WORD)
(SELECTQ WORD
(RELEVANT (QUOTE IRRELEVANT))
(IRRELEVANT (QUOTE RELEVANT))
(STATIC (QUOTE DYNAMIC))
(DYNAMIC (QUOTE STATIC))
(LE (QUOTE GT))
(GT (QUOTE LE))
(LT (QUOTE GE))
(GE (QUOTE LT))
(HAPPY (QUOTE SAD))
(SAD (QUOTE HAPPY))
(COND
((MATCH (TUPLE U N FRAG1)
(UNPACK WORD))
(PACK FRAG1))
(T (PACK (LIST (QUOTE UN)
WORD)))))))
(OUTFORM
(LAMBDA (X L)
(COND
((NOT (LISTP L))
(LIST L))
((MEMBER X L)
NIL)
(T (LIST (APPEND (OUTFORM X (CAR L))
(CAR (OUTFORM X (CDR L)))))))))
(OUTNIL
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
NIL)
(OUTNIL (CDR S)))
(T (CONS (OUTNIL (CAR S))
(OUTNIL (CDR S)))))))
(OUTQUOTE
(LAMBDA (S)
(COND
((NOT (LISTP S))
S)
((EQUAL (CAR S)
(QUOTE QUOTE))
(CONS TUPLE (OUTQUOTE (CADR S))))
(T (CONS (OUTQUOTE (CAR S))
(OUTQUOTE (CDR S)))))))
(OUTTUPLE
(LAMBDA (S)
(COND
((NOT (LISTP S))
S)
((EQUAL (CAR S)
TUPLE)
(OUTTUPLE (CDR S)))
(T (CONS (OUTTUPLE (CAR S))
(OUTTUPLE (CDR S)))))))
(OUTVECTOR
(LAMBDA (S)
(COND
((NOT (LISTP S))
S)
((EQUAL (CAR S)
VECTOR)
(OUTVECTOR (CDR S)))
(T (CONS (OUTVECTOR (CAR S))
(OUTVECTOR (CDR S)))))))
(PBT
(LAMBDA NIL
(MAPDL (FUNCTION (LAMBDA (X)
(COND
((OR (MEMBER X PUP6FNS)
(MEMBER X IS:BEING:LIST))
(PUPRIN1 X)
(PUPRIN1 " "))))))
"***TOP***"))
(PBTV
(LAMBDA NIL
(MAPDL (FUNCTION (LAMBDA (X)
(COND
((OR (MEMBER X PUP6FNS)
(MEMBER X IS:BEING:LIST))
(PUPRINT X)
(PUPRINT (VARIABLES MAPDLPOS))
(PUPRINT (STKARGS MAPDLPOS))
(TERPRI))))))))
(PERMIT:DETAILED:DECISION
(LAMBDA NIL
(TERPRI)
(PUPRIN1 "SHOULD I DISCUSS RAMIFICATIONS?")
(COND
((EQUAL (PREAD)
YES)
(PUPRIN1 "I ASK NOW BECAUSE")
(PUPRIN1 (CADDDR D))
(PUPRIN1 " HAS THE NON-NULL VALUE ")
(PUPRIN1 (EVAL (CADDDR D)))
(COND
((MEMBER WHY (CADR D))
(PUPRIN1 "THIS, IN TURN, IS")
(PUPRIN1 (CDADR (MEMBER WHY (CADR D))))
(TERPRI)))
(COND
((MEMBER COMMENT (CADR D))
(PUPRIN1 "
ANOTHER COMMENT ABOUT THIS IS:
")
(PUPRINT (EVAL (CADR (MEMBER COMMENT (CADR D)))))))
(PUPRINT (CONCAT "ALL THIS IS IN THE FUNCTION " CHOICE))
(SELECTQ
DTYPE
(BOOLEAN (PUPRIN1 " THE EFFECT OF
ANSWERING YES IS ")
(PUPRIN1 (COND
((APPEND (CADR (MEMBER YES:RESULTS (CADR D)))
(CADR (MEMBER BOTH:RESULTS (CADR D)))))
(T (CDDADR (MEMBER AFFECTS (CADR D))))))
(TERPRI)
(PUPRIN1 (COND
((APPEND (CADR (MEMBER NO:RESULTS (CADR D)))
(CADR (MEMBER BOTH:RESULTS (CADR D)))))
(T "THE EFFECT OF ANSWERING NO IS THUS NO:EFFECT"))))
(SOMEOF
(PUPRIN1
"
WE SHALL REPEATEDLY DO SOME OF THESE ACTIONS. YOUR REPLY TELLS ME
WHICH ONE(S) ARE ACTUALLY INVOLVED IN THIS FUNCTION. YOUR ANSWER
AFFECTS ")
(PUPRINT (CDADR (MEMBER AFFECTS (CADR D)))))
(PROGN (PUPRIN1 "
YOUR REPLY AFFECTS ")
(PUPRINT (CDADR (MEMBER AFFECTS (CADR D))))))))))
(PERMIT:USER:INTERRUPT
(LAMBDA NIL
(COND
(EXPERTISE (PRIN1 "INTERRUPT? "))
(T (PRIN1 "
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (READ)
(YES (PROCESS:USER:INTERRUPT))
(NO T)
(PROGN (PRIN1 "
NO, NO. TYPE YES OR NO ......... ")
(PERMIT:USER:INTERRUPT)))))
(PLISTMATCH
(LAMBDA (PAT NODE DAC D2)
(COND
((AND (LISTP (CDAR NODE))
(EQUAL (QUOTE NODE)
(CAR (COLON:BREAK (CAR NODE)))))
(MAPCONC NODE (FUNCTION (LAMBDA (NODE2)
(COND
((PLISTMATCH PAT NODE2)
(PUPRINT (CDR NODE2))
(LIST NODE2)))))))
((AND (LISTP (CDAR PAT))
(EQUAL (QUOTE NODE)
(CAR (COLON:BREAK (CAR PAT)))))
(PLISTMATCH NODE PAT))
(T (OR (NULL PAT)
(AND (EQUAL (LIST (CADR PAT))
(PROGN (SETQ DAC (CADR (MEMBER (QUOTE ACCESS)
(GETP (CAR PAT)
DATA:STRUCTURE))))
(SETQ D2 (SUBST (QUOTE NODE)
DSN
(COPY DAC)))
(EVAL D2)))
(PLISTMATCH (CDDR PAT)
NODE)))))))
(PLURAL
(LAMBDA (OBJECT)
(COND
((MATCH (TUPLE FRAG1 ANY1 OF ANY2)
(COLON:BREAK OBJECT))
(COLON:BACK (APPEND FRAG1 (LIST (PACK (LIST ANY1 (QUOTE S)))
(QUOTE OF)
ANY2))))
(T (PACK (LIST OBJECT (QUOTE S)))))))
(POP:DEMONS
(LAMBDA NIL
(SETQ CURRENT:DEMONS (CAR DEMON:STACK))
(SETQ DEMON:STACK (CDR DEMON:STACK))
T))
(PREAD
(LAMBDA (T82)
(COND
(PREADLIST (SETQ T82 (CAR PREADLIST))
(SETQ PREADLIST (CDR PREADLIST))
(PUPRINT T82))
(T (READ)))))
(PREDICT:AFFECT
(LAMBDA (B I CHOICE2)
(SETQ CHOICE2 (LIST VECTOR B))
(DETERMINE:ARG:VALUE CHOICE2)
(DETERMINE:ARG2:VALUE CHOICE2)
(SUBPAIR (LIST ARG1 ARG2)
(TUPLE ARG1 ARG2)
I)))
(PREPL
(LAMBDA (NEW OLD BP)
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(COND
((SETQ BP (GETP B P))
(PUT B P (SUBST NEW OLD (COPY BP)))))))))))
(MAPC PUP6FNS (FUNCTION (LAMBDA (F)
(PUTD F (SUBST NEW OLD (COPY (GETD F)))))))
(MAPC (APPEND PUP6VARS (TUPLE PUP6FNS PUP6VARS))
(FUNCTION (LAMBDA (V)
(COND
((ATOM V)
(SET V (SUBST NEW OLD (COPY (EVAL V)))))))))))
(PRET
(LAMBDA (FN VAL)
(RETFROM (STKPOS FN)
VAL)))
(PROCEDURE:INTERSECTION
(LAMBDA (P P1 YTEMP)
(SETQ P1 (CAAR P))
(COND
((MEMBER NIL (MAPCAR (CDR P)
(FUNCTION (LAMBDA (P2)
(EQUAL (CAR P2)
P1)))))
NIL)
((EQUAL P1 (QUOTE PROGN))
(SETQ YTEMP (MULT:INTERSECTION (MAPCAR P (QUOTE CDR))))
(COND
((LESSP (LENGTH YTEMP)
2)
(CAR YTEMP))
(T (CONS P1 YTEMP))))
((LESSP (LENGTH P)
2)
(CAR P))
(T NIL))))
(PROCEDURE:PULLOUT
(LAMBDA (PIECE BODY PPRESULT)
(SETQ PPRESULT (COND
((NULL PIECE)
BODY)
((EQUAL (CAR BODY)
(CAR PIECE))
(CONS (CAR BODY)
(SETDIFFERENCE (CDR BODY)
(CDR PIECE))))
(T (CONS (CAR BODY)
(SETDIFFERENCE BODY (LIST (CAR BODY)
PIECE))))))
(COND
((MATCH (TUPLE PROGN ANY1)
PPRESULT)
ANY1)
(T PPRESULT))))
(PROCEDURE:SUBSET
(LAMBDA (A1 A2)
(NOT (MEMBER NIL (MAPCAR (CDR A1)
(FUNCTION (LAMBDA (A3)
(MEMBER A3 A2))))))))
(PROCESS:USER:INTERRUPT
(LAMBDA NIL
(PROG (RESPONSE BC BC1 BC2)
(COND
((NOT EXPERTISE)
(PRINT (APPEND (QUOTE (BEING IS))
(LIST (CAR BEING:STACK))))
(PRIN1 " TYPE ? OR ")))
(SETQ BC (CAR BEING:STACK))
(SETQ BC1 NIL)
(SETQ BC2 (CDR BEING:STACK))
L (PRIN1 " REQUEST: ")
(SELECTQ
(SETQ RESPONSE (READ))
(CH (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(?
(PRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PRIN1
"SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
")
(PRIN1 "NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
")
(PRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(PRIN1
(CONCAT
"
TYPING ONE OF THESE WILL PRINT OUT " BC "'S ANSWER TO THAT QUESTION:
" SET:OF:BEING:PARTS
"
(USING ONE AS THE ARG TO THE FUNCTION $ WILL CAUSE THAT ANSWER
TO BE EEVALLED AFTER IT IS LOCATED)
")))
(QUIT (COND
((NOT EXPERTISE)
(PRIN1 "
END OF INTERRUPT
")))
(RETURN T))
(FAIL (RETURN NIL))
(SPEC:WHEN (PRINT (MAPCAR (GETP BC WHEN)
(FUNCTION (LAMBDA (W)
(TUPLE (CAR W)
IS
(SETQ W2 (EVAL (CAR W)))
SO WE (COND
(W2 (QUOTE DO))
(T (QUOTE DONT)))
ADD IN THE WEIGHT (CADR W)
WHICH
IN THE CURRENT CASE IS (EVAL (CADR W))
;THE EXPLANATION IS (EVAL (CADDR W)))))))
(PRINT (TUPLE THE FINAL WHEN VALUE IS THUS (A:BEING:WHEN BC))))
(BEING (PRINT BC))
(CONTROL:HISTORY (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(DEMONS (PRIN1 CURRENT:DEMONS)
(PRIN1 "
THE DEMON STACK IS ")
(PRINT DEMON:STACK))
(OLDER (SETQ BC1 (NCONC1 BC1 BC))
(SETQ BC (CAR BC2))
(SETQ BC2 (CDR BC2))
(PRINT BC))
(NEW:LEVEL (NEW:LEVEL))
(YOUNGER (SETQ BC2 (CONS BC BC2))
(SETQ BC (LAST BC1))
(SETQ BC1 (REVERSE (CDR (REVERSE BC1))))
(PRINT BC))
(OLDEST (SETQ BC (LAST BEING:STACK))
(SETQ BC1 (REVERSE (CDR (REVERSE BEING:STACK))))
(SETQ BC2 NIL)
(PRINT BC))
(YOUNGEST (SETQ BC (CAR BEING:STACK))
(SETQ BC2 (CDR BEING:STACK))
(SETQ BC1 NIL)
(PRINT BC))
(COND
((MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (OUTTUPLE (GETP BC RESPONSE)))))
((MEMBER RESPONSE EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (EVAL (GETP BC RESPONSE)))))
((AND (ATOM RESPONSE)
(EQUAL (CAR (UNPACK RESPONSE))
$)
(SETQ RES2 (PACK (CDR (UNPACK RESPONSE))))
(MEMBER RES2 SET:OF:BEING:PARTS))
(SETQ RES3 (GETP BC RES2))
(PRINT (EVAL (OUTVECTOR (COND
((MEMBER RES2 EVAL:BEING:PARTS)
(EVAL RES3))
(T RES3))))))
((NLSETQ (PRINT (EVAL RESPONSE)))
T)
(T (PRIN1 "
*** ERROR *** TYPE ? FOR ASSISTANCE **********
")
(GO L))))
(GO L))))
(PROGRAM:WRITING:DEMONS
(LAMBDA NIL T))
(PSYCHOLOGY:DEMON
(LAMBDA NIL T))
(PULLOUT
(LAMBDA (E L ETEMP)
(COND
((PROGN (SETQ ETEMP (PULLOUT1 E L))
(NOT (EQUAL ETEMP L)))
ETEMP)
((LISTP E)
(MINTERSECTION (MAPCAR E (FUNCTION (LAMBDA (EE)
(PULLOUT1 EE L))))))
(T L))))
(PULLOUT1
(LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT1 E (CDR L)))))))
(PUPP
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((APPLY* (QUOTE PP)
ST)))))
(PUPRETTYPRINT
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((PRETTYPRINT ST)))))
(PUPRIN1
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((PRIN1 ST)))))
(PUPRINT
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((PRINT ST)))))
(PUSH:DEMONS
(LAMBDA (NEW:DEMONS NEW:DEMO)
(SETQ NEW:DEMO (SETDIFFERENCE NEW:DEMONS CURRENT:DEMONS))
(SETQ CURRENT:DEMONS (APPEND NEW:DEMO CURRENT:DEMONS))
(SETQ DEMON:STACK (CONS CURRENT:DEMONS DEMON:STACK))))
(RANDOMSELECT
(LAMBDA (S1 S2)
(COND
(S1 (CAR (NTH S1 (RAND 1 (LENGTH S1)))))
(S2 (CAR (NTH S2 (RAND 1 (LENGTH S2)))))
(T (PRINT (COMMENT UNABLE TO MAKE A SELECTION))
NIL))))
(REINVESTIGATION:DEMON
(LAMBDA NIL
(MAPCAR DEFERRED:DECISION:LIST (FUNCTION (LAMBDA (D)
(COND
((EVAL (CADDDR D))
(REINVESTIGATE:DECISION D))
(T NOT:TIME:YET)))))
T))
(RELEVANT
(LAMBDA (L)
(EVAL (CDR L))))
(REMOVE:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ EFFECTS:TABLE (PULLOUT E EFFECTS:TABLE)))))))
(REMOVE:IDEN
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ IDEN:TABLE (PULLOUT E IDEN:TABLE)))))))
(RFAST
(LAMBDA (SPEED)
(MAPC FAST:BEING:LIST SWITCHFAST)
(MAPC FAST:FUNCTION:LIST SWITCHFN)))
(SELECT:STRUCTURE:TYPE
(LAMBDA (MCODE)
(COND
((AND (GREATERP (LENGTH MCODE)
3)
(NULL (SETINTERSECTION MCODE PART:INTERSECTION:LIST)))
(QUOTE PROPERTY:LIST))
(T (QUOTE LIST:VALUE)))))
(SEMI:COMPILE
(LAMBDA (B DTAG)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (TUPLE (COND
((GETP B NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ))))
(LIST (APPEND (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK))))
(COND
((SETQ DTAG (SETDIFFERENCE (GETP B DEMONS)
TRIVIAL:DEMON:LIST))
(LIST (LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS))))
(T NIL))
(COND
((NOT (EQUAL T (GETP B EXPLICIT:ARGS:CHECK)))
(LIST (GETP B EXPLICIT:ARGS:CHECK)))
(T NIL))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(GETP B COMMENTS)
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X)))))
(LIST (LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE)))
(COND
((GETP B INHIBIT:CURRENT:DEMONS)
(QUOTE ((NOT (MEMBER NIL (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(T (QUOTE ((NOT (MEMBER NIL (MAPCAR (APPEND
CURRENT:DEMONS
USER:INTERRUPT:DEMONS)
(QUOTE APPLY*))))))))
(LIST (LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE)))
(COND
((GETP B CO:REQUISITES)
(QUOTE ((NOT (MEMBER NIL (MAPCAR FINAL:CO:REQ SATISFY)))
)))
(T NIL))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(QUOTE (FN:VALUE)))
(QUOTE (SETQ BEING:STACK (CDR BEING:STACK))))
(COND
(DTAG (QUOTE ((POP:DEMONS))))
(T NIL))))))))))
(SET:UP:EFFECTS:TABLE
(LAMBDA (TEMPTOO E:TABLE)
(SETQ E:TABLE NIL)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B MAIN:EFFECTS))))))
(SETQ EFFECTS:TABLE (COPY E:TABLE))
(SORT EFFECTS:TABLE CAAR:ORDER)
(LENGTH EFFECTS:TABLE)))
(SET:UP:IDEN:TABLE
(LAMBDA (TEMPTOO E:TABLE)
(SETQ E:TABLE FUNDAMENTAL:IDEN:TABLE)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B IDEN))))))
(SETQ IDEN:TABLE (COPY E:TABLE))
(SORT IDEN:TABLE CAAR:ORDER)
(LENGTH IDEN:TABLE)))
(SETDIFFERENCE
(LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND (COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1))))
(SETDIFFERENCE (CDR S1)
S2))))))
(SETINTERSECTION
(LAMBDA (S1 S2)
(INTERSECTION S1 S2)))
(SETUNION
(LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1)))
(SINGLETON
(LAMBDA (S)
(NULL (CDR S))))
(SINGULAR
(LAMBDA (L)
(COND
((MATCH (TUPLE FRAG2 S)
(UNPACK L))
(PACK FRAG2))
(T L))))
(SIZE
(LAMBDA (STRUC)
(ADD1 (IQUOTIENT (COUNT STRUC)
2))))
(SNAPSHOT
(LAMBDA (SLEVEL)
(SETQ SNAPFNS SLEVEL)
(MAKEFILE SNAP)))
(SPECIFICITY:CHECK:DEMON
(LAMBDA (ANYTHING)
(MAPC (SETDIFFERENCE PUP:WANTS:LIST IS:SPECIFIC:LIST)
MAKE:SPECIFIC)
T))
(START
(LAMBDA (EXPERTISE)
(PROG NIL
L1 (SETQ BEING:STACK NIL)
(SETQ BECAUSE (VECTOR))
(SETQ FORCE:TRANSLATE NIL)
(SETQ DEMON:STACK NIL)
(SETQ CURRENT:DEMONS NIL)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SET L NIL))))
L2 (COND
(EXPERTISE (PUPRIN1 "USER INTERRUPT LEVEL... "))
(T
(PUPRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
(SETQ DOING:PUP:LIST (QUOTE ((COMMENT END OF LIST MARKER))))
L (SETQ PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ
(PREAD)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND
(PUPRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
L3 (SERVE)
L4 (COND
(EXPERTISE
(PUPRIN1
"
FINISHED CURRENT SERVICE; WHAT SHOULD I DO? TYPE ONE OF:
1 EXIT FROM SYSTEM
2 CONTINUE SERVING, AS BEFORE
3 CONTINUE SERVING, BUT GET A NEW USER INTERRUPT LEVEL
4 REINITIALIZE SYSTEM AND START FROM BEGINNING AGAIN
OK, GO .......... "))
(T (PUPRIN1 "
FINISHED SERVICE. 1 EXIT; 2 CONTINUE; 3 NEW LEVEL; 4 START OVER ")))
(SELECTQ (PREAD)
(2 (GO L3))
(3 (GO L2))
(4 (GO L1))
(1 "EXITING SYSTEM")
(PUPRIN1 "NO, NO!!!!! ")
(GO L4)))))
(STRUCTURE
(NLAMBDA FORM
(CONS STRUCTURE FORM)))
(STRUCTURE:COMPATIBLE
(LAMBDA (B1 B2)
(COND
((AND (HIGHLY:STRUCTURED B1)
(HIGHLY:STRUCTURED B2)
(EQUAL (LENGTH (GETP B1 META:CODE))
(LENGTH (GETP B2 META:CODE))
(NOT (MEMBER NIL (MAP2CAR (GETP B1 META:CODE)
(GETP B2 META:CODE)
(FUNCTION (LAMBDA (P1 P2)
(EQUAL (CADR P1)
(CADR P2))))))))))
(T NIL))))
(STRUCTURE:INDUCING:DEMON
(LAMBDA (OBJECT PIECES)
(SETQ STAG NIL)
(COND
((GETP OBJECT BEING)
SORRY:NOT:IN:YET)
((AND (NULL (DETERMINE:ARG:VALUE CHOICE))
(NULL OBJECT))
(PUPRIN1
"
AT THIS POINT, I ALMOST RECOMMENDED VIRTUAL STRUCTURING, BUT DECIDED
AGAINST IT. THE LIST STRUCTURE WOULD HAVE BEEN DIVIDED INTO THESE
PIECES: ")
(PUPRINT PIECES)
(PUPRINT (TUPLE I GUESS THAT EACH OF THE ABOVE :NIL-S WOULD GET REPLACED
BY SOMETHING LIKE (CONCAT ":" (CAR (COLON:BREAK (CAR PIECES)))
(QUOTE :LIST))))
(TERPRI)
T)
((NULL OBJECT)
(TERPRI)
(PUPRINT (TUPLE IF SOME SORT OF (SETQ POSLIST (PACK (TUPLE KNOWN:LIST:OF:(PLURAL ARG1))))
EXISTED,
THEN I WOULD RECOMMEND THAT IT BE STRUCTURED INTO (LENGTH PIECES)
PIECES, NAMED (@ PIECES)
,ALTHOUGH I GUESS THAT THE "NIL" -S SHOULD BE REPLACED
BY (@ POSLIST)-S.
IF SUCH A LIST IS LATER CREATED, THIS COMMENT WILL STILL APPLY, BUT A GREAT DEAL
OF CODE MAY HAVE
TO BE CHANGED.))
(TERPRI))
((PROGN (TERPRI)
(PUPRINT (TUPLE I RECOMMEND THAT (@ OBJECT)
BE STRUCTURED INTO (TUPLE AT LEAST ALONG ONE DIMENSION)
THESE
(LENGTH PIECES)
PIECES:(@ PIECES)
.PLEASE TYPE BACK YES, NO, OR UNSURE.))
(PUPRIN1 "
USER: ")
(MEMBER (PREAD)
(QUOTE (Y YES T UNSURE MAYBE))))
(PROG (CODE BNAME)
(SETQ CODE (APPEND (STRUCTURE)
(MAPCAR PIECES (FUNCTION (LAMBDA (PIECE)
(TUPLE (@ PIECE)
SET OF (PLURAL ARG1)))))))
(SETQ BNAME LIST:STRUCTURE)
(SATISFY (VECTOR IS BEING OBJECT)))
(SETQ CODING:WARNING:LIST (CONS (TUPLE 10 VECTOR IN ALL CODE GENERATED, (@ OBJECT)
SHOULD BE REPLACED
BY (CONS (QUOTE APPEND)
PIECES))
CODING:WARNING:LIST))
(LONG:NAME:DEMON)
(SETQ STAG T))
(T (PUPRIN1 "
OK, SO WE JUST GO ON NOW.
")))))
(SUBALLEVELS
(LAMBDA (NEW OLD FORM)
(COND
((CDR (COLON:BREAK OLD))
(SUBST NEW OLD FORM))
((NULL FORM)
NIL)
((LISTP FORM)
(CONS (SUBALLEVELS NEW OLD (CAR FORM))
(SUBALLEVELS NEW OLD (CDR FORM))))
((EQUAL FORM OLD)
NEW)
((ATOM FORM)
(COLON:BACK (SUBST NEW OLD (COLON:BREAK FORM))))
(FORM))))
(SUBSTITUTE
(LAMBDA (NEW FOR OLD IN L:STRUCTURE)
(SET L:STRUCTURE (SUBST NEW OLD (APPEND (EVAL L:STRUCTURE))))))
(SWITCHFAST
(LAMBDA (B1 B2 STEMP)
(SETQ B2 (PACK (LIST (QUOTE FAST:)
B1)))
(SETQ STEMP (CDR B1))
(RPLACD B1 (CDR B2))
(RPLACD B2 STEMP)
(SEMI:COMPILE B1)
(SEMI:COMPILE B2)))
(SWITCHFN
(LAMBDA (F1 F2 STEMP)
(SETQ F2 (PACK (LIST (QUOTE FAST:)
F1)))
(MOVD F1 (QUOTE STEMP)
T)
(MOVD F2 F1 T)
(MOVD (QUOTE STEMP)
F2 T)))
(TEMPORARILY
(LAMBDA (L)
(EVAL (CDR L))))
(TRACE:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (COND
((GETP B NLAMBDA)
(LIST NLAMBDA))
(T (QUOTE (LAMBDA))))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ))))
(LIST (APPEND (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK)))))
(LIST (LIST (QUOTE PUPRINT)
(GETP B EXPLICIT:ARGS:CHECK)))
(COND
((GETP B DEMONS)
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS))))))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PUPRINT)
(LIST SATISFY X)))))
(QUOTE ((PUPRINT "COMMENTS BEGINNING")))
(GETP B COMMENTS)
(QUOTE ((PUPRINT "COMMENTS ENDING")))
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PUPRINT)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X))))))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE))))
(QUOTE ((PUPRIN1 "NOT1 ")))
(COND
((GETP B INHIBIT:CURRENT:DEMONS)
(QUOTE ((NOT (MEMBER NIL (PUPRINT (MAPCAR
USER:INTERRUPT:DEMONS
(QUOTE APPLY*)
)))))))
(T (QUOTE ((NOT (MEMBER NIL (PUPRINT (MAPCAR
(APPEND
USER:INTERRUPT:DEMONS
CURRENT:DEMONS)
(QUOTE APPLY*))))))
)))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE))))
(QUOTE ((PUPRIN1 "NOT2 ")))
(QUOTE ((NOT (MEMBER NIL (PUPRINT (MAPCAR FINAL:CO:REQ
SATISFY))))))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PUPRINT)
(LIST SATISFY X)))))
(QUOTE (FN:VALUE)))
(QUOTE (SETQ BEING:STACK (CDR (PUPRINT BEING:STACK)))))
(COND
((GETP B DEMONS)
(QUOTE ((POP:DEMONS)
(PUPRIN1 (CONCAT "
DEMON:STACK ENDS UP, FROM " B ", AS " DEMON:STACK))))))))))))))
(TRUE:MINIMUM
(LAMBDA (L F MINV MIN TV ELE NEWNUM MINNUM LHOLD MN MNTEMP)
(SETQ MNTEMP 1)
(SETQ MN 1)
(SETQ LHOLD L)
(SETQ L (OUTVECTOR L))
(SETQ MIN (CAR L))
(SETQ MINV (APPLY* F MIN))
(MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(SETQ MNTEMP (ADD1 MNTEMP))
(COND
((OR (LESSP (SETQ TV (APPLY* F ELE))
MINV)
(AND (EQUAL TV MINV)
(OR (AND (NUMBERP NEWNUM)
(NOT (NUMBERP MINNUM)))
(AND (NUMBERP NEWNUM)
(NUMBERP MINNUM)
(LESSP NEWNUM MINNUM)))))
(SETQ MIN ELE)
(SETQ MN MNTEMP)
(SETQ MINNUM NEWNUM)
(SETQ MINV TV))))))
(CAR (NTH LHOLD MN))))
(TRY:TO:SATISFY
(LAMBDA (SUBGOAL)
(COND
((SATISFY SUBGOAL)
T)
(T (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ))))))
(TUPLE
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F2)
(COND
((NOT (LISTP F2))
F2)
(T (EVAL F2))))))))
(UNGERUNDIFY
(LAMBDA (W WLIST UFRAG RUFRAG)
(MATCH (TUPLE FRAG1 I N G)
(UNPACK W))
(SETQ UFRAG FRAG1)
(SETQ RUFRAG (REVERSE UFRAG))
(COND
((EQUAL (CAR RUFRAG)
(CADR RUFRAG))
(SETQ UFRAG (REVERSE (CDR RUFRAG)))))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(COND
((MATCH (APPEND UFRAG (TUPLE FRAG1))
(UNPACK B))
(SETQ WLIST (CONS B WLIST)))))))
(COND
((LESSP (LENGTH WLIST)
2)
(CAR WLIST))
(T (SELECTQ (PACK UFRAG)
(GET (QUOTE GET:HOLD:OF))
(CAR WLIST))))))
(USER:INTERRUPT:AT:ADAPTING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ADAPT:PRECONCEIVED:FUNCTION)
(PERMIT:USER:INTERRUPT))
(T T))))
(USER:INTERRUPT:AT:CODING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ENCODE)
(PERMIT:USER:INTERRUPT))
(T T))))
(USER:INTERRUPT:AT:DEBUG
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
CLARIFY:IMPROBABLE:SITUATION)
(PERMIT:USER:INTERRUPT))
(T T))))
(USER:INTERRUPT:AT:END
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
OPTIMIZE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:END USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT))
(T T))))
(USER:INTERRUPT:AT:PHASES
(LAMBDA (S:EXP)
(COND
((MEMBER (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES))
(TERPRI)
(PUPRINT (CAR BEING:STACK))
(PUPRIN1 "IS BEING REMOVED FROM THE LIST OF INTERRUPTING BEINGS
")
(PERMIT:USER:INTERRUPT))
(T T))))
(VECTOR
(NLAMBDA FORM
(CONS VECTOR (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((NOT (LISTP F1))
F1)
(T (EVAL F1)))))))))
(VECTOR:AVERAGE
(LAMBDA (L CVLIST CVLEN)
(SETQ CVLIST (CONS (LIST .8 .8 .8 .8 .1)
(MAPCONC L (FUNCTION (LAMBDA (B)
(COND
((DIMENSION1 B)
(LIST (MAPCAR (GETP B COMPLEXITY:VECTOR)
(QUOTE EVAL))))))))))
(SETQ CVLEN (LENGTH CVLIST))
(MAPCAR (VECTOR:SUM CVLIST)
(FUNCTION (LAMBDA (CV)
(QUOTIENT CV CVLEN))))))
(VECTOR:SUM
(LAMBDA (L)
(COND
((NULL L)
(LIST .1 .1 .1 .1 .1))
((NULL (CDR L))
(CAR L))
(T (VECTOR:SUM (CONS (MAP2CAR (CAR L)
(CADR L)
(QUOTE PLUS))
(CDDR L)))))))
(WHEN:VALUE
(LAMBDA (B:CALL EXP:A)
(SETQ EXP:A (GETP (CAR B:CALL)
EXPLICIT:ARGS))
(MAP2C EXP:A (CDR B:CALL)
(FUNCTION (LAMBDA (NEWARG OLDARG)
(SET NEWARG OLDARG))))
(COND
((EVAL (GETP (CAR B:CALL)
EXPLICIT:ARGS:CHECK))
(A:BEING:WHEN (CAR B:CALL)))
(T -1000))))
(Z@
(LAMBDA (X)
X))
)
(RPAQQ $ $)
(RPAQQ ADAPTATION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ
ADAPTATION:RESOLVE:DECISION:KNOWLEDGE
(PROGN
(PUPRIN1
"
HERE I WILL EVENTUALLY ASK FOR A SAMPLE DIALOGUE AND USE IT TO
DETERMINE ALL THE FORMATS, AND TO CHECK ALL THE CODE. NOT IN YET
")
(INSERT:PRINT:STATEMENTS)))
(RPAQQ ADJECTIVES (STATIC DYNAMIC HARD SOFT COMMENTED UNCOMMENTED NAMED UNNAMED EASY SIMPLE COMPLEX BIG LITTLE SMALL
LARGE))
(RPAQQ AFFECTS:ALL AFFECTS:ALL)
(RPAQQ AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR THE BASIC STRUCTURE OF FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE AMOUNT OF EFFORT ANY1 SHOULD SPEND ON FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR HOW ANY1 STORES FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF STORING)
FRAG2)
DOING:PUP:LIST))
((VECTOR DETAILS OF THE ANY1 ALGORITHM)
(TUPLE SOME TYPE:OF:LIST (TUPLE FUNCTION (TUPLE LAMBDA (TUPLE TOL)
(TUPLE AND (TUPLE MATCH (VECTOR ANY1 TYPE OF
(LIST VECTOR ANY1
(QUOTE FRAG2))
IS ANY2)
TOL)
(TUPLE MEMBER ANY1 IS:BEING:LIST))))))
((VECTOR THE ANY2 ALGORITHM)
(TUPLE SOME DOING:PUP:LIST (TUPLE FUNCTION (TUPLE LAMBDA (QUOTE (PD))
(TUPLE MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ANY2
(QUOTE FRAG2)))
PD)))))
((VECTOR CODE INVOLVING ANY1)
(TUPLE INSIDE (@ ANY1)
DOING:PUP:LIST
(TUPLE FUNCTION (TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT (TUPLE OR (TUPLE EQUAL (@ ANY1)
PD)
(TUPLE MEMBER (@ ANY1)
(TUPLE COLON:BREAK PD))
(TUPLE EQUAL (@ ANY1)
(TUPLE COLON:BACK (TUPLE REVERSE
(TUPLE CDR
(TUPLE REVERSE
(TUPLE
COLON:BREAK PD))
))))))))))
((VECTOR WHAT INFORMATION ANY1 MAY USE TO ANY2 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY2 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR ANY1 DETAILS)
(TUPLE MEMBER (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
DOING:PUP:LIST))))
(RPAQQ ALPHORDER ALPHORDER)
(RPAQQ ALTERNATIVES:DEFER:DECISION:KNOWLEDGE ((COND ((AND (NOT (MEMBER NIL (MAPCAR (SETQ C (CDADR DEC))
(FUNCTION (LAMBDA (D)
(GETP D BEING))))
))
(SETQ PROC (INVECTOR (PROCEDURE:INTERSECTION
(MAPCAR C (FUNCTION (LAMBDA
(D)
(GETP D
META:CODE)))))
)))
(COND ((EQUAL TASK (INVECTOR (LAST DEC)))
(SETQ TNAME TASK:NAME))
(T (GET:NAME (INVECTOR (LAST DEC))
(VECTOR TNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ TNAME)
TYPE OF (LAST DEC)
IS
(VECTOR TEMPORARILY
(@ PROC)))
(CONS (CADR (LAST DEC))
TYPE:OF:LIST)))
(COND ((SETQ
S8
(CAR (SOME C (FUNCTION
(LAMBDA (D)
(MEMBER
(GETP D META:CODE)
(LIST PROC (LIST (QUOTE PROGN)
PROC))))))))
(SETQ S9 (COLON:BACK
(CONS (QUOTE TYPE:OF)
(INITIALS (COLON:BREAK (CADR (LAST DEC))))))
)
(SET S9 S8)
(SETQ GLOBAL:INITIALIZATION:LIST
(CONS (TUPLE SETQ (@ S9)
(@ S8))
GLOBAL:INITIALIZATION:LIST))))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (@ TNAME)
TYPE OF
(INVECTOR
(LAST DEC)))
ENCODABLE:SECTION:LIST))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION (SETDIFFERENCE (COND ((LESSP (LENGTH PROC)
3)
(LIST PROC))
(T PROC))
ABLE:PUP:LIST)
UNDEFINED:SECTION:LIST))
(TUPLE PROCEDURE:SUBSET (@ PROC)
ABLE:PUP:LIST))
(T NIL))))
(RPAQQ ALTERNATIVES:RESOLVE:DECISION:KNOWLEDGE
(PROGN (PUPRIN1 "
SINCE WE HAVE A SIMPLE SET OF ALTERNATIVES, SIMPLY TYPE IN YOUR CHOICE")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "
USER: ")
(COND ((NOT (SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(MATCH (VECTOR (CADR CHOICE)
TYPE OF ANY2 IS ANY1)
TOL)))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(VECTOR (PREAD)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))))
(RPAQQ AND:LOOP:TERMINATION:KNOWLEDGE (SET RESULT:PLACE
(APPEND (EVAL RESULT:PLACE)
(MAPCONC (CDR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST))
(FUNCTION
(LAMBDA
(FUNC)
(COND
((NOT (NUMBERP (CAR (LAST (COLON:BREAK
(CAR FUNC))))))
NIL)
((SETQ INTSEC (INTERSECTION (COPY
DISTINGUISHED:ARG:LIST)
(CDR FUNC)))
(LIST (LIST (CAR FUNC)
(SASSOC (CAR INTSEC)
DISTINGUISHED:INFO:LIST)
T
(VECTOR T NIL))))
(T (LIST (LIST (CAR FUNC)
T))))))))))
(RPAQQ APPLIED:SO:AS:TO:KEEP APPLIED:SO:AS:TO:KEEP)
(RPAQQ ARG1 NAME:OF:CLASS)
(RPAQQ ARG1 NAME:OF:CLASS)
(RPAQQ ARG1 NAME:OF:CLASS)
(RPAQQ ASSERT:LISTS
(GLOBAL:INITIALIZATION:LIST ABLE:PUP:LIST ABLE:USER:LIST ATTEMPTING:ANYTHING:LIST ATTEMPTING:SOMETHING:LIST
AWARE:PUP:LIST AWARE:USER:LIST PROBABLE:TESTS:LIST IS:CONSTRAINED:LIST
CODING:WARNING:LIST DEFERRED:DECISION:LIST DISTINGUISHED:ARG:LIST
DISTINGUISHED:INFO:LIST DOING:PUP:LIST ENCODABLE:SECTION:LIST EXECUTABLE:INFO:LIST
FN:CALL:LIST USER:WARNING:LIST SOME:INSERTIONS:LIST SOME:DELETIONS:LIST
FRINGE:CONCIOUS:LIST INITIALIZE:VAR:LIST IS:DEFINED:LIST IS:SPECIFIC:LIST
IS:STRUCTURE:LIST ISNT:STRUCTURE:LIST KNOWN:NAMES LOOP:TERMINATION:LIST
MEMBER:OF:LIST NAMED:EXPRESSION:LIST NEW:INFO:LIST NEW:THING:LIST
PART:INTERSECTION:LIST PARTITIONED:DOMAIN:LIST PLAUSIBLE:NAMES:LIST
PUP:SATISFIED:LIST PUP:STUDIED:LIST PUP:WANTED:LIST PUP:WANTS:LIST READ:USER:LIST
RELEVANT:INFO:LIST RESOLVED:DECISION:LIST RESULT:BINDING:LIST TRANSLATED:INFO:LIST
TRANSLATED:PAIR:LIST TRUE:FN:CALL:LIST TYPE:OF:LIST UNDEFERRED:DECISION:LIST
UNDEFINED:SECTION:LIST USABLE:INFO:LIST USER:WANTS:LIST WRITTEN:PROGRAMS:LIST))
(RPAQQ BEING BEING)
(RPAQQ BOOLEAN:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ BOOLEAN:RESOLVE:DECISION:KNOWLEDGE
(PROGN (PUPRIN1 "SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(SETQ IRES (CADR (MEMBER (COLON:BACK
(TUPLE (COND ((SETQ HH (CADR (MEMBER (QUOTE HINT)
(CADR D))))
(PUPRIN1 "
HA!! I HAVE A HINT WHICH RESOLVES THIS FOR ME!!
")
(COND ((EVAL HH)
(QUOTE YES))
(T (QUOTE NO))))
(T (PUPRIN1 "NOW TYPE YOUR ANSWER: ")
(PREAD)))
RESULTS))
(CADR D))))
(COND ((ATOM (CAR IRES))
(EVAL IRES))
(T (MAPC IRES (QUOTE EVAL))))
(SETQ IRES2 (CADR (MEMBER BOTH:RESULTS (CADR D))))
(COND ((ATOM (CAR IRES2))
(EVAL IRES2))
(T (MAPC IRES2 (QUOTE EVAL))))
(PUPRIN1 "
OK, READY TO MOVE ON NOW.
")))
(RPAQQ BOTH:RESULTS BOTH:RESULTS)
(RPAQQ BREAKUP:LIST (: ; %. , - ? = +))
(RPAQQ CALL CALL)
(RPAQQ COMEVAL COMEVAL)
(RPAQQ COMMENT COMMENT)
(RPAQQ COMPILABLE:BEING:PARTS (META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES EXPLICIT:ARGS
EXPLICIT:ARGS:CHECK IMPLICIT:ARGS DEMONS INHIBIT:CURRENT:DEMONS))
(RPAQQ DEFINITION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ
DEFINITION:RESOLVE:DECISION:KNOWLEDGE
(PROGN
(SETQ DEFINED:OBJECT (CAR (LAST (CDADR D))))
(COND ((NOT (MEMBER NIL (MAPCAR UNDEFINED:SECTION:LIST (FUNCTION (LAMBDA (US1)
(NOT (COND ((MATCH (VECTOR ANY1 TYPE OF
(LIST VECTOR
DEFINED:OBJECT)
FRAG1)
US1)
(SETQ HOLD:ANY1 ANY1)
(SETQ HOLD:FRAG1 FRAG1)
T))))))))
(SETQ HOLD:ANY1 DEFINED:OBJECT)
(SETQ HOLD:FRAG1 NIL)))
(PUPRIN1 "SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
TYPE IN THE DEFINITION OF ")
(PUPRIN1 HOLD:ANY1)
(COND
((AND (SETQ TCALL (SASSOC HOLD:ANY1 TRUE:FN:CALL:LIST))
(GETP DEFINED:OBJECT PREDICATE))
(PUPRIN1
(CONCAT
"
SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
LOGICAL EXPRESSION, WHICH IS TRUE IF "
(CADR TCALL)
" IS OF
THE "
(CDADDR TCALL)
" TYPE, AND SHOULD BE FALSE IF IT ISNT OF
THAT TYPE.
"))))
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "USER: ")
(SETQ NEW:INFO:LIST (CONS (VECTOR DEFINE (@ HOLD:ANY1)
AS
(INVECTOR (PREAD)))
NEW:INFO:LIST))))
(RPAQQ DICHOTOMY:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ
DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ ENT1 (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST))
(SETQ ENT2 (CADR ENT1))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE))
TOL)
(SETQ ARG1 ANY1))))))
(PUPRINT (TUPLE ABOVE, ARG1 REFERS TO (@ ARG1)
;ALSO, PLEASE IGNORE THE THIRD 'CHOICE'; IT IS ONLY FOR ME TO LOOK AT))
(COND
((SETQ TRESULT (NLSETQ (EVAL (EVAL (CADDR (CADR D))))))
(SETQ TRESULT (CAR TRESULT))
(PUPRIN1
"
AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
USER CHANNEL AFTER ALL!!!
"))
(T (PUPRIN1 (CONCAT "
SINCE THE DECISION IS DICHOTOMOUS, TYPE A 1 OR A MEANS THAT IS C" (EVAL (CADR (CADDR (CADR D))))
" IS CORRECT.
2 MEANS THAT "
(EVAL (CADDR (CADDR (CADR D))))
" IS CORRECT.
"))
(PERMIT:DETAILED:DECISION)
(PUPRIN1 "
USER: ")
(SETQ TRESULT (EQUAL (PREAD)
1))))
(SETQ NEWPIECE (CDADR (MEMBER RESULTS (CADR D))))
(SETQ NEWPIECE (COND (TRESULT (CAR NEWPIECE))
(T (CADR NEWPIECE))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(INVECTOR (EVAL NEWPIECE)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
(RPAQQ DOES DOES)
(RPAQQ DOESNT DOESNT)
(RPAQQ DUMMY:ARGUMENT DUMMY:ARGUMENT)
(RPAQQ EQUAL EQUAL)
(RPAQQ EQUALS EQUALS)
(RPAQQ EVAL EVAL)
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY PREDICATE DATA:STRUCTURE INHIBIT:CURRENT:DEMONS FORM:CHANGING
ENCODABLE NON:EVAL:ARGS NLAMBDA))
(RPAQQ EXPERTAG NIL)
(RPAQQ EXPERTISE NOBIND)
(RPAQQ FALSE FALSE)
(RPAQQ FAST:BEING:LIST (SATISFY GET:NAME))
(RPAQQ FAST:COMPLEX FAST:COMPLEX)
(RPAQQ FAST:FUNCTION:LIST (A:BEING:ORDER))
(RPAQQ FINAL:PREADLIST
(NIL YES YES YES YES YES NO YES YES YES T YES YES MODIFY:STRUCTURE:39 YES MODIFY:STRUCTURE:40 YES
MODIFY:STRUCTURE:41 YES MODIFY:STRUCTURE:42 NO NIL))
(RPAQQ FLOW:ASSIGNMENT (COMMENT HER IS THE FLOW ASSIGNMENT, WHICH SHOULD ACTUALLY BE SET BY THE FLOW:PRECEDED ROUTINE)
)
(RPAQQ FOREVER FOREVER)
(RPAQQ FUNDAMENTAL:IDEN:TABLE (((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE))))))))
(RPAQQ GI:DIALOG GI:DIALOG)
(RPAQQ GLOBAL:CONTEXT:0 GLOBAL:CONTEXT:0)
(RPAQQ GO GO)
(RPAQQ HOLDX X)
(RPAQQ INFERIOR INFERIOR)
(RPAQQ ING ING)
(RPAQQ IS IS)
(RPAQQ IS:BEING:LIST
(MODIFY:STRUCTURE:7 CONTRADICTS:27 POSSIBLE:NAME:OF:CLASS:RELNS:22 COMPARE:26 COMPARE:25 COMPARE:24 JOIN:23
COMPARE:19 POSSIBLE:NAME:OF:CLASS TEST:18 FOREACH:17 GET:HOLD:OF:8 TAKE:HOLD:OF:6
TAKE:HOLD:OF:3 HAS:NAME:5 ELEMENT:4 STATIC:SCENE:10 PAD:2 CF:1 ADAPT:PRECONCEIVED:FUNCTION
ADD:DEFINITION ADJECTIVE:HANDLER ANALYZE:IMPLICATIONS APPLYRULE ASK:USER:ABOUT BETTER
CHOOSE:FROM CLARIFY:IMPROBABLE:SITUATION CLASSIFICATORY:CONCEPT:FORMATION COMPARE
COMPARITIVE:CONCEPT:FORMATION COMPLEX:ALTERATION COMPLEX:COMPARE:FN
COMPLEX:MODIFY:STRUCTURE CONCEPT:FORMATION CONDITIONAL:DELETION CONDITIONAL:INSERTION
CONSTRAIN DATA:STRUCTURE:DELETIONS DATA:STRUCTURE:INSERTIONS DEFER:DECISION ELEMENT ENCODE
EXAMINE:STRUCTURE EXTRACT:RELEVANT:SUBSET FAST:GET:NAME FAST:SATISFY
FILL:IN:UNDEFINED:SECTION FIX:INCORRECT:PIECE FOREACH GET:DATA:STRUCTURE GET:HOLD:OF
GET:NAME GET:NEW:INFORMATION GRAMMATICAL:INFERENCE INFER:CONTEXTFREE:GRAMMARS
INFER:CONTEXTSENSITIVE:GRAMMARS INFER:FIXEDCLASS:GRAMMARS INFER:MULTICLASS:GRAMMARS
INFER:PHRASESTRUCTURE:GRAMMARS INFER:REGULAR:GRAMMARS IS:OF:TYPE JOINING:FUNCTION
LIST:STRUCTURE MAJOR:MODIFY:STRUCTURE MAKE:A:GUESS MAKE:ENCODABLE MAKE:NEW:BEING MESSAGE
METRICAL:CONCEPT:FORMATION MODIFY:SOME MODIFY:STRUCTURE MODIFY:UNTIL
OBTAIN:USABLE:INFORMATION OPTIMIZE PARSE PARSE:BACKWARD PARSE:FORWARD PARTITION:A:DOMAIN
PARTITION:BY:TAKE:CLASS:GET:ELE PARTITION:BY:TAKE:ELE:AND:CLASS
PARTITION:BY:TAKE:ELE:GET:CLASS PATTERN:MATCH PROBABILITY=0:# PROBABILITY=1:#
PROBABILITY>0&<1:# PROPOSE:PLAUSIBLE:NAMES RECOGNIZE:# RECOGNIZE:ARGS RECOGNIZE:CAR
RECOGNIZE:CONDITIONAL RECOGNIZE:CONJUNCTION RECOGNIZE:EQUALITY RECOGNIZE:FUNCTION:RETURNS
RECOGNIZE:INCLUSION RECOGNIZE:LITERALS RECOGNIZE:NUMBER RECOGNIZE:SET:RELATIONS
RECOGNIZE:SOME:MEMBER RECOGNIZE:TAIL REINVESTIGATE:DECISION REPEATEDLY RESOLVE:DECISION
SATISFY SCENE SEARCH SERVE SIMPLE:COMPARE:FN SOME:PART:OF STRING STUDY:TYPE SUPPORT&DUMP
TAKE:HOLD:OF TEST TRANSLATE USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ ISNT ISNT)
(RPAQQ KNOWLEDGE KNOWLEDGE)
(RPAQQ LABEL:COUNTER 2)
(RPAQQ LEFT:SIDE LEFT:SIDE)
(RPAQQ
LIST:VALUE:SETUP
(INVECTOR
(LIST (QUOTE INITIALIZE)
(TUPLE SETQ (@ SNAME)
(PROGN (COND ((EQUAL (CAR (QUOTE DSMATCH))
(QUOTE NOBIND))
(SETQ DSMATCH MATCH)))
(SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(TUPLE 97 VECTOR COMMENT WARNING INITIAL:VALUE IN (@ SNAME)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL SINCE
(VECTOR WE KNOW NONE TO BEING WITH; THE LIST STRUCTURE SHOULD GROW WITH
TIME))))
(QUOTE INITIAL:VALUE)))
(QUOTE ACCESS)
SNAME
(QUOTE INSERT)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE SETQ)
SNAME
(TUPLE MERGE:IN
(COND
((EQUAL (CAR DSN)
(QUOTE NOBIND))
(QUOTE X))
(T (TUPLE COND (TUPLE (TUPLE ATOM X)
X)
(TUPLE T (TUPLE SETQ NEW:NODE (TUPLE PACK
(TUPLE TUPLE (TUPLE QUOTE NODE:)
(TUPLE SETQ NEW:F:NUMBER
(TUPLE ADD1
NEW:F:NUMBER)))))
(QUOTE (MAP2C (EVEN:ALT X)
(ODD:ALT X)
(FUNCTION
(LAMBDA (P V)
(SETQ
D1
(CADDAR (CADR (MEMBER (QUOTE INSERT)
(GETP P
DATA:STRUCTURE)))))
(SETQ D2 (SUBST V HOLDX (COPY D1)))
(SETQ D3 (SUBST (QUOTE NEW:NODE)
DSN D2))
(EVAL D3)))))
NEW:NODE))))
(@ SNAME)
BETTER)))
INSERTS X INTO (@ SNAME))
(QUOTE DELETE)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE SETQ)
SNAME
(TUPLE PULLOUT X (@ SNAME))))
DELETES X FROM (@ SNAME)))))
(RPAQQ LONG:TAG T)
(RPAQQ MINOR:WORDS (A AT OF DO ATOMIC DOES FOR IN PROGRAM THE TO WHICH WHILE WRITE IDENTIFIER))
(RPAQQ NAME UNKNOWN)
(RPAQQ NEW:P:NUMBER 614)
(RPAQQ NO:RESULTS NO:RESULTS)
(RPAQQ NON:EVAL:BEING:PARTS (IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES))
(RPAQQ NON:EXECUTABLE NON:EXECUTABLE)
(RPAQQ NOT:TIME:YET NOT:TIME:YET)
(RPAQQ ONETYPE ONETYPE)
(RPAQQ ONETYPE:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ONETYPE:RESOLVE:DECISION:KNOWLEDGE (COND ((EQUAL (LAST D)
(TUPLE FIXUP))
(EVAL (CADR (MEMBER RESULTS (CADR D)))))
(T (SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(EVAL (CADR (MEMBER RESULTS (CADR D)))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST)))))
(RPAQQ PARTS PARTS)
(RPAQQ PERMANENT:KNOWN:NAMES NIL)
(RPAQQ POSSIBLE POSSIBLE)
(RPAQQ PREADLIST (CLASS:OBJECTS CLASS:CLASSNAME CLASS:YES:RELNS CLASS:NO:RELNS CLASS:MAYBE:RELNS YES NO YES ARG1
(RESULT:2 ISNT NOTHING)
YES T NIL YES YES YES NO YES YES YES NIL NO NIL NO NIL NO NIL NO NIL NO 1 NIL NO T NO
1 NO (A C)
NO NIL NO NIL NO YES ARG1 (RESULT:3 ISNT NOTHING)
T YES YES YES YES YES NO YES YES YES T YES YES MODIFY:STRUCTURE:39 YES
MODIFY:STRUCTURE:40 YES MODIFY:STRUCTURE:41 YES MODIFY:STRUCTURE:42 NO NIL NO NO YES
YES YES NO NIL NO NIL NO NIL NO (A)
NO NIL NO NO YES (EVERYTHING IN ELEMENT:OBJECTS:11 WHICH IS NOT IN
POSSIBLE:NAME:OF:CLASS:OBJECTS:20)
NIL NO NIL NO 2 NIL NO T NO (B)
NIL NO NO YES (EVERYTHING IN YES:RELNS:28 WHICH IS NOT IN ELEMENT:RELNS:15)
NIL NO (B)
NO NIL NO NO YES (EVERYTHING IN NO:RELNS:29 WHICH IS IN ELEMENT:RELNS:15)
NIL NO (A)
NO NIL NO NO YES
(RESULT:5 AND RESULT:6 AND EVERYTHING IN ELEMENT:RELNS:15 WHICH IS NOT IN ANY OF
YES:RELNS:28 NO:RELNS:29 MAYBE:RELNS:30)
NIL YES BETTER:38 YES (A)
NO NIL NO YES (SOMETHING IN MAYBE:RELNS:30 WHICH IS NOT IN ELEMENT:RELNS:15)
(RESULT:8 ISNT NIL AND POSSIBLE:NAME:OF:CLASS ISNT NAME:OF:CLASS AND
POSSIBLE:NAME:OF:CLASS ISNT NOTHING)
YES BETTER:38 NO (A)
NO NIL NO YES (SOMETHING IN ELEMENT:RELNS:15 WHICH IS NOT IN ANY OF YES:RELNS:28
MAYBE:RELNS:30)
(RESULT:8 EQUALS NIL AND RESULT:9 ISNT NIL AND POSSIBLE:NAME:OF:CLASS ISNT NOTHING
AND POSSIBLE:NAME:OF:CLASS ISNT NAME:OF:CLASS)
YES BETTER:38 NO (B)
NO NIL NO YES (RESULT:8 AND RESULT:9)
(RESULT:10 ISNT NIL AND POSSIBLE:NAME:OF:CLASS ISNT NAME:OF:CLASS AND
POSSIBLE:NAME:OF:CLASS ISNT NOTHING)
NO 1 (CADR ARG1)
NO 2 (THE FRONT PART OF ARG1)
NO 1 (CDDR ARG1)
NO 1))
(RPAQQ PREDICATE:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ PREDICATE:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ F:CALL (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST))
(SETQ OUTER:FN (CAR (LAST F:CALL)))
(SETQ RESULT:PLACE (CADR (MEMBER RESULTS (CADR D))))
(SETQ SRESP NIL)
(SETQ IS:DONE (SASSOC (CADR CHOICE)
(EVAL RESULT:PLACE)))
(COND ((EVAL (CADR IS:DONE))
(SET IS:DONE NIL)
(PUPRIN1 "
AHA!! I'VE RESOLVED THIS PREDICATE-GETTING DECISION MYSELF.
"))
(T (SETQ RESPONSE (OR SRESP (PROGN (PUPRIN1 "
PLEASE TYPE IN A LOGICAL EXPRESSION WHICH IS TRUE ")
(PUPRIN1 (CADR (MEMBER PREDICATE (CADR D))))
(PUPRIN1 " AND IS FALSE OTHERWISE.
")
(PERMIT:DETAILED:DECISION)
(PUPRIN1 "
USER: ")
(TUPLE QUOTE (OUTVECTOR (TRANSLATE (INVECTOR (PREAD))
T))))))
(SETQ A:COUNT 0)
(SETQ A:LIST (MAPCAR (CDR F:CALL)
(FUNCTION (LAMBDA (DA)
(PACK (TUPLE ARG (SETQ A:COUNT (ADD1 A:COUNT))))))))
(SETQ TFN (APPLY* (OUTVECTOR (CADR (MEMBER HOW (CADR D))))
(EVAL RESPONSE)))
(COND ((OR (MATCH (TUPLE DO UNTIL (TUPLE FORSOME ANY1 IN ANY2 FRAG1))
RESPONSE)
(PROG1 (MATCH (TUPLE QUOTE (TUPLE DO UNTIL (TUPLE FORSOME ANY1 IN ANY2 FRAG1)))
RESPONSE)
(SETQ RESPONSE (CADR RESPONSE))))
(SETQ DISTINGUISHED:ARG:LIST (CONS ANY2 DISTINGUISHED:ARG:LIST))
(SETQ DISTINGUISHED:INFO:LIST (CONS (LIST ANY2 (CADDR RESPONSE))
DISTINGUISHED:INFO:LIST))
(SETQ MEMBER:OF:LIST (CONS (LIST ANY1 ANY2)
MEMBER:OF:LIST))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(INVECTOR (COND ((ATOM TFN)
(CONS TFN A:LIST))
(TFN))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SETQ BRESULT (COLON:BREAK RESULT:PLACE))
(EVAL (EVAL (COLON:BACK (LIST TFN (CAR BRESULT)
(CADR BRESULT)
(QUOTE KNOWLEDGE)))))))))
(RPAQQ PRIMITIVE:PROGRAMS:LIST
(AND OR NOT COND T NLSETQ ERSETQ MAPC MAPCAR LAMBDA FUNCTION ANTIRULE ALLSUBSTS PLUS TIMES MERGE:IN LIST
APPEND CONS CAR CDR CADR CADDR CADDDR CADAR MINUS MINUSP QUOTIENT ADD1 SUB1 SET SETQ NULL QUOTE EVAL
LESSP EQUAL TEMPORARILY NIL RELEVANT IRRELEVANT PROG PROGN CDAR CDDR CAAR CAADR CAAAR CDADR PROG1 PREAD
PUPRINT PUPRIN1 PRIN2 PRIN1 PRINT READ RATOM COPY ALPHORDER MERGE))
(RPAQQ PRIMITIVE:VARS:LIST (T NIL 0 1 2 3 4 5 6 7 8 9 10 -1 -2 -3))
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION USE:INFORMATION FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCEIVED:FUNCTION CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE OPTIMIZE))
(RPAQQ
PROPERTY:LIST:SETUP
(PROGN
(PUPRIN1
(CONCAT
"
I HAVE DECIDED TO KEEP " SNAME
" STRUCTURED USING THE PROPERTY LIST
FEATURE OF LISP. FOR THIS REASON, I NEED TO HAVE A NAME FOR EACH
PROPERTY (CORRESPONDING TO EACH SUBPART OF " SNAME ") :
"))
(SETQ SCODENAMES (MAPCAR (CDR SCODE)
(QUOTE CADDR)))
(SETQ PROPNAMES (MAPCAR (CDR SCODE)
(FUNCTION (LAMBDA (POS)
(SETQQ CNAME CNAME)
(GET:NAME (INVECTOR POS)
(VECTOR CNAME))
(SETQ GLOBAL:INITIALIZATION:LIST (CONS (LIST (QUOTE SETQQ)
CNAME CNAME)
GLOBAL:INITIALIZATION:LIST))
CNAME))))
(COND ((EQUAL (CAR (QUOTE DSMATCH))
(QUOTE NOBIND))
(SETQ DSMATCH PLISTMATCH)))
(SETQ ACCESS:PART (MAP2CAR SCODENAMES PROPNAMES (FUNCTION (LAMBDA (PROP PROPNAME)
(TUPLE (TUPLE GETP (@ SNAME)
(@ PROPNAME))
ACCESSES
(@ PROP))))))
(SETQ INSERT:PART (MAP2CAR SCODENAMES PROPNAMES (FUNCTION (LAMBDA
(PROP PROPNAME)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE MERGE:IN X
(LIST (QUOTE GETP)
SNAME PROPNAME)
BETTER)))
INSERTS X INTO (@ PROP))))))
(SETQ INIT:PART
(MAP2CAR SCODENAMES PROPNAMES
(FUNCTION (LAMBDA (PROP PROPNAME)
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 50 VECTOR COMMENT (PACK (LIST (QUOTE INITIAL:VALUE:OF:)
PROP))
IN
(@ SNAME)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL OR SOME
ALREADY-READ-IN VALUE SINCE
(VECTOR INITIAL VALUES ARE RARELY COMPUTED INTRICATELY; THEY
ARE TYPICALLY CONSTANT, OFTEN NIL, OR ARE READ IN AT
THE BEGINNING))
CODING:WARNING:LIST))
(TUPLE (LIST (QUOTE SETQ)
PROP
(LIST (QUOTE PUT)
SNAME PROPNAME (PACK (LIST (QUOTE INITIAL:VALUE:OF:)
PROP))))
INITIALIZES
(@ PROP))))))
(SETQ DELETE:PART (MAP2CAR SCODENAMES PROPNAMES (FUNCTION (LAMBDA
(PROP PROPNAME)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE PULLOUT X
(LIST (QUOTE GETP)
SNAME PROPNAME))))
DELETES X FROM (@ PROP))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B IPART BFLAT)
(SETQ IPART (SETINTERSECTION (APPEND SCODENAMES)
(APPEND (SETQ BFLAT (FLATTEN (GETP B META:CODE))))))
(SETQ CODE (GETP B META:CODE))
(MAP2C SCODENAMES PROPNAMES (FUNCTION
(LAMBDA (PROP PROPNAME)
(COND ((MEMBER PROP IPART)
(SETQ CODE (COND ((EQUAL (CAR CODE)
(QUOTE PROGN))
(APPEND (TUPLE (CAR CODE)
(TUPLE SETQ (@ PROP)
(TUPLE GETP ARG1
(@ PROPNAME))))
(CDR CODE)))
(T (LIST (QUOTE PROGN)
(TUPLE SETQ (@ PROP)
(TUPLE GETP ARG1 (@ PROPNAME)))
CODE)))))))))
(COND ((AND IPART (MATCH (TUPLE ARG1 IS INSTANTIATED AS (@ ENAME))
(MEMBER (QUOTE ARG1)
BFLAT))
(NOT (MEMBER (CAR CODE)
(VECTOR COMMENT STRUCTURE))))
(SETQ ARG:LIST (GETP B EXPLICIT:ARGS))
(SETQ FARGS NIL)
(PUT B META:CODE (GETCODE CODE B -1)))))))
(PROG (CODE FNAME BNAME)
(SETQ CODE (STRUCTURE ATOM))
(SETQ BNAME LIST:STRUCTURE)
(SETQ IS:STRUCTURE:LIST (APPEND IS:STRUCTURE:LIST SCODENAMES (MAPCAR SCODENAMES (FUNCTION (LAMBDA
(SN)
(LIST VECTOR SN
NIL))))))
(MAP2C SCODENAMES PROPNAMES (FUNCTION (LAMBDA
(PROP PROPNAME)
(SETQ FNAME PROP)
(SATISFY (VECTOR IS BEING FNAME))
(PUT PROP DATA:STRUCTURE
(VECTOR INITIALIZE (LIST (QUOTE PUT)
SNAME PROPNAME
(PACK (LIST (QUOTE INITIAL:VALUE:OF:)
PROP)))
ACCESS
(LIST (QUOTE GETP)
SNAME PROPNAME)
INSERT
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE MERGE:IN X
(LIST (QUOTE GETP)
SNAME PROPNAME)
BETTER)))
INSERTS X INTO (@ PROP))
DELETE
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE PULLOUT X
(LIST (QUOTE GETP)
SNAME PROPNAME))))
DELETES X FROM (@ PROP))))))))
(INVECTOR (LIST (QUOTE INITIALIZE)
INIT:PART
(QUOTE ACCESS)
ACCESS:PART
(QUOTE INSERT)
INSERT:PART
(QUOTE DELETE)
DELETE:PART))))
(RPAQQ RESULT:COUNTER 1)
(RPAQQ RESULTS RESULTS)
(RPAQQ RIGHT:SIDE RIGHT:SIDE)
(RPAQQ SET:OF SET:OF)
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA NON:EVAL:ARGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS
MINOR:EFFECTS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS AFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES PREDICATE DATA:STRUCTURE ENCODABLE
INHIBIT:CURRENT:DEMONS FORM:CHANGING))
(RPAQQ SET:OF:BEINGS
(ADAPT:PRECONCEIVED:FUNCTION ADD:DEFINITION ADJECTIVE:HANDLER ANALYZE:IMPLICATIONS APPLYRULE ASK:USER:ABOUT
BETTER CHOOSE:FROM CLARIFY:IMPROBABLE:SITUATION CLASSIFICATORY:CONCEPT:FORMATION
COMPARE COMPARITIVE:CONCEPT:FORMATION COMPLEX:ALTERATION COMPLEX:COMPARE:FN
COMPLEX:MODIFY:STRUCTURE CONCEPT:FORMATION CONDITIONAL:DELETION
CONDITIONAL:INSERTION CONSTRAIN DATA:STRUCTURE:DELETIONS
DATA:STRUCTURE:INSERTIONS DEFER:DECISION ELEMENT ENCODE EXAMINE:STRUCTURE
EXTRACT:RELEVANT:SUBSET FAST:GET:NAME FAST:SATISFY FILL:IN:UNDEFINED:SECTION
FIX:INCORRECT:PIECE FOREACH GET:DATA:STRUCTURE GET:HOLD:OF GET:NAME
GET:NEW:INFORMATION GRAMMATICAL:INFERENCE INFER:CONTEXTFREE:GRAMMARS
INFER:CONTEXTSENSITIVE:GRAMMARS INFER:FIXEDCLASS:GRAMMARS
INFER:MULTICLASS:GRAMMARS INFER:PHRASESTRUCTURE:GRAMMARS INFER:REGULAR:GRAMMARS
IS:OF:TYPE JOINING:FUNCTION LIST:STRUCTURE MAJOR:MODIFY:STRUCTURE MAKE:A:GUESS
MAKE:ENCODABLE MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION MODIFY:SOME
MODIFY:STRUCTURE MODIFY:UNTIL OBTAIN:USABLE:INFORMATION OPTIMIZE PARSE
PARSE:BACKWARD PARSE:FORWARD PARTITION:A:DOMAIN PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:AND:CLASS PARTITION:BY:TAKE:ELE:GET:CLASS PATTERN:MATCH
PROBABILITY=0:# PROBABILITY=1:# PROBABILITY>0&<1:# PROPOSE:PLAUSIBLE:NAMES
RECOGNIZE:# RECOGNIZE:ARGS RECOGNIZE:CAR RECOGNIZE:CONDITIONAL
RECOGNIZE:CONJUNCTION RECOGNIZE:EQUALITY RECOGNIZE:FUNCTION:RETURNS
RECOGNIZE:INCLUSION RECOGNIZE:LITERALS RECOGNIZE:NUMBER RECOGNIZE:SET:RELATIONS
RECOGNIZE:SOME:MEMBER RECOGNIZE:TAIL REINVESTIGATE:DECISION REPEATEDLY
RESOLVE:DECISION SATISFY SCENE SEARCH SERVE SIMPLE:COMPARE:FN SOME:PART:OF STRING
STUDY:TYPE SUPPORT&DUMP TAKE:HOLD:OF TEST TRANSLATE USE:INFORMATION UTILIZE
WHEN:NEXT WRITE:PROGRAM))
(RPAQQ SINCE SINCE)
(RPAQQ SNAP SNAP)
(RPAQQ SNAPFNS NIL)
(RPAQQ SNAPVARS
(EXPERTAG OLD:PREADLIST FINAL:PREADLIST PREADLIST LONG:TAG ABLE:PUP:LIST PROBABLE:TESTS:LIST
IS:CONSTRAINED:LIST ABLE:USER:LIST ANY1 ANY2 SOME:INSERTIONS:LIST SOME:DELETIONS:LIST
ISNT:STRUCTURE:LIST ANY3 ARG1 ARG2 ARG3 ATTEMPTING:ANYTHING:LIST ATTEMPTING:SOMETHING:LIST
AWARE:USER:LIST BECAUSE BEING:STACK CHOICE CODING:WARNING:LIST CURRENT:DEMONS DEFERRED:DECISION:LIST
DEMON:STACK DISTINGUISHED:ARG:LIST DISTINGUISHED:INFO:LIST DOING:PUP:LIST ENCODABLE:SECTION:LIST
EXECUTABLE:INFO:LIST FN:CALL:LIST FRAG1 FRAG2 FRINGE:CONCIOUS:LIST GLOBAL:INITIALIZATION:LIST
INITIALIZE:VAR:LIST IS:BEING:LIST IS:DEFINED:LIST IS:SPECIFIC:LIST IS:STRUCTURE:LIST KNOWN:NAMES
LOOP:TERMINATION:LIST MATCH:RESULT MEMBER:OF:LIST NAMED:EXPRESSION:LIST NEW:INFO:LIST NEW:THING:LIST
PART:INTERSECTION:LIST PARTITIONED:DOMAIN:LIST PLAUSIBLE:NAMES:LIST PUP:STUDIED:LIST PUP:WANTED:LIST
PUP:WANTS:LIST READ:USER:LIST RELEVANT:INFO:LIST RESULT:BINDING:LIST RESULT:COUNTER NEW:F:NUMBER
NEW:P:NUMBER SET:OF:BEINGS TRANSLATED:INFO:LIST TRANSLATED:PAIR:LIST TRUE:FN:CALL:LIST TYPE:OF:LIST
UNDEFERRED:DECISION:LIST UNDEFINED:SECTION:LIST UNKNOWN:TASK USABLE:INFO:LIST USER:INTERRUPT:DEMONS
USER:WANTS:LIST WRITTEN:PROGRAMS:LIST (COMS * (LIST (APPEND (QUOTE (PROP ALL))
(SETDIFFERENCE IS:BEING:LIST
SET:OF:BEINGS))))
(P (PRIN1 " WARNING: NEW BEINGS ARE NOT SEMICOMPILED ")
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(SET B B)))))))
(RPAQQ SOMEOF:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ SOMEOF:RESOLVE:DECISION:KNOWLEDGE
(PROG (IN:SET:TRANS)
(PUPRIN1 "SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF: ")
(TERPRI)
(MAP2C (CDAR (CDDADR D))
(QUOTE (A B C D E F))
(FUNCTION (LAMBDA (D1 L1)
(PUPRINT (LIST L1 (QUOTE ....)
D1)))))
(PUPRIN1 "
FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "USER: ")
(COND ((SETQ IN:SET (PREAD))
(MAP2C (QUOTE (A B C D E F))
(CDAR (CDDADR D))
(FUNCTION (LAMBDA (L1 D1)
(COND ((MEMBER L1 IN:SET)
(SETQ IN:SET:TRANS (NCONC1 IN:SET:TRANS D1)))))))
(COND ((GREATERP (LENGTH (SETQ PROC (PROCEDURE:INTERSECTION (SETQ T0
(MAPCAR
IN:SET:TRANS
(FUNCTION
(LAMBDA
(B)
(MAPC (GETP B COMMENTS)
(QUOTE EVAL))
(INSTANTIATE
(GETP B META:CODE)))))))
))
2)
(SETQ T1 (COND ((EQUAL (CAR PROC)
(QUOTE PROGN))
(MEMBER (CADR PROC)
(CAR T0)))
(T (MEMBER (CAR PROC)
(CAR T0)))))
(SETQ T2 (LDIFF T1 (MEMBER (CAR (LAST PROC))
T1)))
(SETQ T3 (SETDIFFERENCE T2 PROC))
(COND (T3 (SETQ PROC (CAR T1))))
PROC))
(COND ((CDR IN:SET)
(STRUCTURE:INDUCING:DEMON (SETQ OUTERLIST (CADR (SASSOC ARG1 MEMBER:OF:LIST)))
(SETQ PIECES (MAPCAR (CDAR (CDDADR D))
(FUNCTION (LAMBDA
(PIECE)
(COLON:BACK
(LIST PIECE (QUOTE PART:OF)
OUTERLIST)))))))))))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(COND ((LESSP (LENGTH IN:SET:TRANS)
2)
(MAPC (GETP (CAR IN:SET:TRANS)
COMMENTS)
(QUOTE EVAL))
(INSTANTIATE (GETP (CAR IN:SET:TRANS)
META:CODE)))
(T (VECTOR (COND ((GETP (CAR (LAST (CADR D)))
PREDICATE)
(QUOTE PROGN))
(T (QUOTE REPEATEDLY)))
(INVECTOR PROC)
(APPEND (VECTOR COND)
(MAP2CAR IN:SET:TRANS PIECES
(FUNCTION
(LAMBDA
(IST PIECE)
(MAPC (GETP IST COMMENTS)
(QUOTE EVAL))
(VECTOR
(COND ((EQUAL (LAST IN:SET:TRANS)
(LIST IST))
T)
(STAG (VECTOR MEMBER ARG1
(@ PIECE)))
(T (VECTOR IS:OF:TYPE
(COND ((CADDR (INVECTOR
PROC)))
((QUOTE ARG1)))
(LIST VECTOR COMMENT IST))))
(INVECTOR (PROCEDURE:PULLOUT
PROC
(INSTANTIATE (GETP IST META:CODE)
))))))))))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D))))
ENCODABLE:SECTION:LIST))))
(RPAQQ STICKY:BNAME JOINING:FUNCTION)
(RPAQQ STICKY:BPART SPECIALIZATIONS)
(RPAQQ SUBSETOF:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ SUBSETOF:RESOLVE:DECISION:KNOWLEDGE
(PROG (IN:SET:TRANS)
(PUPRIN1 "SINCE THE DECISION IS SUBSET:OF, TYPE ANY ORDERED SUBSET OF: ")
(TERPRI)
(MAP2C (CDAR (CDDADR D))
(QUOTE (A B C D E F))
(FUNCTION (LAMBDA (D1 L1)
(PUPRINT (LIST L1 (QUOTE ....)
D1)))))
(PUPRIN1 "
FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "USER: ")
(SETQ IN:SET (PREAD))
(MAP2C (QUOTE (A B C D E F))
(CDAR (CDDADR D))
(FUNCTION (LAMBDA (L1 D1)
(COND ((MEMBER L1 IN:SET)
(SETQ IN:SET:TRANS (NCONC1 IN:SET:TRANS D1)))))))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (VECTOR PROGN)
(COND ((MAPCAR
IN:SET:TRANS
(FUNCTION
(LAMBDA
(IST)
(APPEND (LIST VECTOR IST)
(COND ((OR (CAR (GETP (CAR (LAST (CADR D)))
EXPLICIT:ARGS))
ARG1)
(TUPLE ARG1)))
(COND ((OR (CADR (GETP (CAR (LAST (CADR D)))
EXPLICIT:ARGS))
ARG2)
(TUPLE ARG2))))))))
(T (TUPLE ARG1 ARG2
(COMMENT AT PRESENT WE HAVE NO BODY FOR THIS FUNCTION, BUT
WE HAVE FAITH THAT OTHER BEINGS WILL GIVE US
MEANING LATER ON))))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D))))
ENCODABLE:SECTION:LIST))))
(RPAQQ SUPERIOR SUPERIOR)
(RPAQQ TASK:TYPE WHEN:NEXT)
(RPAQQ TRIVIAL:BEING:LIST (IN DO))
(RPAQQ TRIVIAL:DEMON:LIST (ATTENTION:DEMONS FRINGE:OF:CONCIOUSNESS:DEMON IDIOM:DEMON INFERENCE:DEMONS
PROGRAM:WRITING:DEMONS PSYCHOLOGY:DEMON))
(RPAQQ UNKNOWN UNKNOWN)
(RPAQQ UNTIL UNTIL)
(RPAQQ WHEN:ALL WHEN:ALL)
(RPAQQ WHEN:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR BEFORE DECIDING FIRMLY HOW TO ANY1 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR BEFORE ANY FRAG2 ROUTINES ARE FINALIZED)
(COND ((MEMBER FRAG2 (QUOTE (NIL (NEW)
(MORE)
(OTHER))))
(TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST))
(FRAG2 (TUPLE MEMBER T (TUPLE MAPCAR (TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
(TUPLE FUNCTION (TUPLE LAMBDA (TUPLE X)
(TUPLE AND (TUPLE OR (TUPLE ATOM X)
(TUPLE SETQ X
(TUPLE CADR
(TUPLE CADDDR X)))
)
(TUPLE OR (TUPLE EQUAL FRAG2 (TUPLE LIST X)
)
(TUPLE SETINTERSECTION
(INTUPLE FRAG2)
(TUPLE GETP X
GENERALIZATIONS)))))))
))))
((VECTOR AFTER ALL FRAG2 ROUTINES ARE FINALIZED)
(COND ((MEMBER FRAG2 (QUOTE (NIL (NEW)
(OTHER)
(THE))))
(TUPLE NULL UNDEFINED:SECTION:LIST))
(T (TUPLE NOT (TUPLE MEMBER (TUPLE CAR FRAG2)
(TUPLE FLATTEN UNDEFINED:SECTION:LIST))))))))
(RPAQQ YES YES)
(RPAQQ YES:RESULTS YES:RESULTS)
(RPAQQ YESNO YESNO)
(RPAQQ YESNO:TAG NO)
(PUTPROPS ADAPT:PRECONCEIVED:FUNCTION BEING T
WHAT (TUPLE ADAPT A PRECONCEIVED, COMMON FUNCTION)
WHEN (T -10000 (COMMENT NOT IN YET))
COMPLEXITY:VECTOR (.9 .9 .9 .9 .9)
FAST:COMPLEX .9)
(PUTPROPS ADD:DEFINITION BEING T
IDEN (((MATCH (TUPLE DEFINE ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE ADD DEFINITION ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T))))
EXPLICIT:ARGS (OBJECT DEFINITION)
EXPLICIT:ARGS:CHECK (ATOM OBJECT)
WHAT (TUPLE ADD THE DEFINITION OF (@ OBJECT)
AS
(@ DEFINITION)
TO PUP'S KNOWLEDGE)
HOW (TUPLE TRIVIALLY, ADD THE DEFN. TO EXISTING DEFNS.)
WHY (TUPLE THE OBJECT (@ OBJECT)
HAS BEEN REFERENCED, AND PUP FEELS UNCOMFORTABLE DISCUSSING ENTITIES IT CAN'T
DEFINE)
META:CODE (PROGN (SETQ ENCODABLE:SECTION:LIST (CONS OBJECT ENCODABLE:SECTION:LIST))
(SETQ TYPE:OF:LIST (MAPCAR TYPE:OF:LIST (FUNCTION
(LAMBDA (TOL)
(COND ((MATCH (VECTOR (@ OBJECT)
TYPE OF ANY1 IS
FRAG1 USED IN
ANY2)
TOL)
(VECTOR (@ OBJECT)
TYPE OF (@ ANY1)
IS
(@ DEFINITION)
AND IS USED IN
(@ ANY2)))
(T TOL))))))
(SETQ IS:DEFINED:LIST (NCONC1 IS:DEFINED:LIST (VECTOR (@ OBJECT)
IS
(@ DEFINITION)))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
NON:EVAL:ARGS T
FAST:COMPLEX .14)
(PUTPROPS ADJECTIVE:HANDLER BEING T
IDEN (((MATCH (TUPLE A DESCRIPTION OF FRAG1)
LI)
(TRANSLATE (INVECTOR (COND ((MEMBER (CAR FRAG1)
(TUPLE A AN THE SOME ANY))
(CDR FRAG1))
(FRAG1)))
T))
((MEMBER (CAR LI)
ADJECTIVES)
(ADJECTIVE:HANDLER (CAR LI)
(APPEND (VECTOR TUPLE)
(CDR (TRANSLATE (INVECTOR (CDR LI))
T))))))
IMPLICIT:ARGS (TNAME BNAME CODE TCODE MCODE)
EXPLICIT:ARGS (ADJ NOUN:GROUP)
EXPLICIT:ARGS:CHECK (MEMBER ADJ ADJECTIVES)
WHAT (TUPLE HANDLE THE ADJECTIVE (@ ADJ)
MODIFYING THE NOUN GROUP (@ NOUN:GROUP))
HOW (TUPLE LOOK AT (@ NOUN:GROUP)
AND SELECT THOSE PARTS WHICH ARE NOT CONTRADICTED BY THE ADJECTIVE
(@ ADJ))
WHY (TUPLE BECAUSE THE (@ ADJ)
PARTS OF (@ NOUN:GROUP)
ARE WANTED, AND THE (OPPOSITE ADJ)
PARTS ARE UNWANTED)
META:CODE (PROGN (SETQ FARGS NIL)
(SETQ BNAME (CAR (LAST NOUN:GROUP)))
(SETQ MCODE (GETP BNAME META:CODE))
(SETQ CODE (COND ((SETQ TCODE (SASSOC (OPPOSITE ADJ)
MCODE))
(PROCEDURE:PULLOUT TCODE MCODE))
((SETQ TCODE (SASSOC ADJ MCODE))
(CONS (CAR MCODE)
(CDR TCODE)))
(T MCODE))))
PRE:REQUISITES ((VECTOR NAMED EXPRESSION (INVECTOR (OUTTUPLE (CONS ADJ NOUN:GROUP)))
(SETQQ TNAME TNAME)))
POST:REQUISITES ((VECTOR IS BEING (@ TNAME)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
COMMENTS ((SET TNAME TNAME))
FAST:COMPLEX .14)
(PUTPROPS ANALYZE:IMPLICATIONS IDEN (((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T)))
((@ (@ (@ (@ (MATCH (TUPLE CHANGE AS FOLLOWS: FRAG1)
LI)))))
(VECTOR ANALYZE:IMPLICATIONS (PROGN (SETQ A8 (LDIFF FRAG1 (MEMBER (QUOTE
INSTEADOF)
FRAG1)))
(SETQ A9 (CDR (MEMBER (QUOTE INSTEADOF)
FRAG1)))
(INVECTOR
(TUPLE (OUTVECTOR (TRANSLATE
(INVECTOR A8)
T))
INSTEADOF
(OUTVECTOR (TRANSLATE
(INVECTOR A9)
T))))))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE ANALYZE THE IMPLICATIONS OF SOME OF THE NEW INFORMATION (@ NEW:INFO))
HOW (TUPLE BY LOCALIZING THE EFFECTS OF THE NEW INFO AND STUDYING THEM)
WHY (TUPLE TO IMPROVE THE UNDERSTANDING THAT PUP HAS OF THE NEW INFORMATION
(@ NEW:INFO))
WHEN (((SETQ ANY1 (CAR USABLE:INFO:LIST))
-60
(TUPLE BECAUSE WE SHOULD USE (@ ANY1)
BEFORE WORRYING ABOUT (@ NEW:INFO)))
(T (DIFFERENCE 50 (SIZE NEW:INFO))
(TUPLE BECAUSE THE SIZE OF THE NEW INFORMATION (@ NEW:INFO)
AFFECTS HOW EASILY AND FRUITFULLY AN ANALYSIS OF IT WILL BE)))
META:CODE (PROGN (SETQ A:A (LOCATE:AFFECTED:AREA NEW:INFO))
(SETQ P:A (PREDICT:AFFECT A:A NEW:INFO))
(EVALUATE:AFFECT P:A A:A)
(PERMIT:USER:INTERRUPT))
EXPLICIT:ARGS:CHECK (OR (NULL RELEVANT:INFO:LIST)
(MEMBER NEW:INFO RELEVANT:INFO:LIST))
MAIN:EFFECTS (((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1))))
AFFECTS (QUOTE ((LOCATE AFFECTED:AREA CALLED)
(PREDICT:AFFECT CALLED)
(EVALUATE:AFFECT CALLED)))
COMPLEXITY:VECTOR (.4 .7 .7 .5 .1)
IMPLICIT:ARGS (A:A P:A)
FAST:COMPLEX .157)
(PUTPROPS APPLYRULE BEING T
EXPLICIT:ARGS (ARG1 ARG2 STRNG)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE DETERMINE IF (@ ARG2)
CAN HAVE ARG1 (@ ARG1)
APPLIED TO IT, AND IF SO APPLY IT)
HOW (TUPLE COMPARE THE STRING WITH THE LEFT SIDE OF THE RULE)
WHY (TUPLE THIS COMPARISON WILL DETERMINE WHETHER AND HOW TO DO THE CHANGE)
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
ENCODABLE T
META:CODE (PROGN ARG1
(COMMENT THIS APPEARANCE OF ARG1 IS SIMPLY TO ENSURE THAT A COMMENT ABOUT ITS
BINDING GETS STUCK IN HERE SOMEWHERE IN THE META:CODE)
(ALLSUBSTS (COPY (EVAL (GETP RULE RIGHT:SIDE)))
(COPY (EVAL (GETP RULE LEFT:SIDE)))
(COPY ARG2)))
FAST:COMPLEX .13)
(PUTPROPS ASK:USER:ABOUT BEING T
IMPLICIT:ARGS (DTYPE IN:SET IN:SET:TRANS TEMPFNVAL)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ASK THE USER TO RESOLVE DECISION (@ D))
HOW (TUPLE ASK THE USER WHAT THE RESOLUTION IS)
WHY (TUPLE BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
META:CODE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(PUPRIN1 "
MOVE CURSOR TO ")
(PUPRINT CHOICE)
(SETQ DTYPE (CADADR D))
(PUPRIN1 "PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS ")
(PUPRIN1 DTYPE)
(PUPRIN1 " DECISION:")
(PUPRIN1 (CDAR (CDDADR D)))
(COND ((MEMBER (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(T (SETQ TEMPFNVAL (EVAL (EVAL (COLON:BACK (LIST DTYPE (CADR
BEING:STACK)
KNOWLEDGE)))))
(COND ((STRINGP TEMPFNVAL)
T)
(T TEMPFNVAL)))))
COMPLEXITY:VECTOR (.6 .6 .6 .6 .1)
IDEN (((MATCH (TUPLE ASK ME FOR FRAG1)
LI)
(VECTOR ASK:USER:ABOUT (VECTOR QUOTE (COLON:BACK FRAG1)))))
SPECIALIZATIONS (VECTOR (VECTOR ONETYPE (VECTOR WE JUST ASK THE USER, NO DECISION TO MAKE)
AFFECTS
(VECTOR THE ASK:USER:ABOUT ALGORITHM)
RESULTS
(VECTOR PROGN (VECTOR PUPRIN1 "
PLEASE GIVE ME ")
(VECTOR PUPRINT ARG1)
(VECTOR SET ARG1 (VECTOR PREAD)))
ASK:USER:ABOUT))
FAST:COMPLEX .15)
(PUTPROPS BETTER IDEN (((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T))))
BEING T
EXPLICIT:ARGS (B1 B2)
WHAT (TUPLE DECIDE WHICH OF (@ B1)
(@ B2)
IS MORE A PROPOS TO TRY)
HOW (TUPLE COMPARE THE WHEN PARTS OF (@ (CAR B1))
AND
(@ (CAR B2))
AND, IF NECESSARY, COMPARE THEIR COMPLEXITY VECTORS)
WHY (TUPLE PUP CAN ONLY TRY AT MOST ONE OF (@ (CAR B1))
AND
(@ (CAR B2))
AT A TIME)
META:CODE (PROGN (SETQ B1NEW B1)
(SETQ B2NEW B2)
(SETQ B1NEW (CONS (CAR B1NEW)
(MAPCAR (CDR B1NEW)
EVAL)))
(SETQ B2NEW (CONS (CAR B2NEW)
(MAPCAR (CDR B2NEW)
EVAL)))
(SETQ WHEN:DIFF (DIFFERENCE (WHEN:VALUE B1NEW)
(WHEN:VALUE B2NEW)))
(COND ((EQP WHEN:DIFF 0)
(SETQ RESULT1 (A:BEING:ORDER (CAR B1NEW)
(CAR B2NEW)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PARTS OF (@ (CAR B1NEW))
AND
(@ (CAR B2NEW))
ARE EQUAL AND THE FORMER IS
(@ (COND (RESULT1 (QUOTE LESS))
(T (QUOTE MORE))))
COMPLEX THAN THE LATTER BEING))))
(T (SETQ RESULT1 (NOT (MINUSP WHEN:DIFF)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PART OF THE
(@ (CAR B1NEW))
IS
(@ (COND (RESULT1 SUPERIOR)
(T INFERIOR)))
TO THE WHEN PART OF
(@ (CAR B2NEW)))))))
RESULT1)
EXPLICIT:ARGS:CHECK (AND (EQUAL T (GETP (CAR B1)
BEING))
(EQUAL T (GETP (CAR B2)
BEING)))
PREDICATE T
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(QUOTE (VECTOR (VECTOR WE USE A SIMPLE, FIXED TYPE OF COMPARING
FUNCTION TO MAINTAIN ORDERING)
(VECTOR WE USE A MORE COMPLEX TYPE OF COMPARING
FUNCTION)
(ERROR!)))
AFFECTS
(VECTOR THE BETTER ALGORITHM)
COMMENT
(COMMENT CHOICE #1 MEANS THAT WE CAN MERGE USING A SIMPLE, QUICK
FUNCTION SUCH AS CONS, NCONC1, ETC; CHOICE #2 INDICATES
THAT AN ACTUAL EVALUATION MUST BE DONE TO COMPARE TWO
ELEMENTS TO DECIDE WHICH COMES FIRST)
RESULTS
(VECTOR (VECTOR SIMPLE:COMPARE:FN)
(VECTOR COMPLEX:COMPARE:FN ARG1 ARG2))
BETTER))
IMPLICIT:ARGS (B1NEW B2NEW WHEN:DIFF RESULT1)
FAST:COMPLEX .14)
(PUTPROPS CHOOSE:FROM IDEN (((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE Y T)))))))
BEING T
IMPLICIT:ARGS (EXP:TEST TEMPBB)
EXPLICIT:ARGS (S)
WHAT (TUPLE CHOOSE THE BEST BEING FROM THE SET (@ S)
OF BEINGS)
HOW (TUPLE COMPARE FEATURES OF THE ELEMENTS OF THE SET (@ S)
OF BEINGS)
WHY (TUPLE BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
META:CODE (PROG (BEST)
(SETQ BEST (CAR S))
(SETQ BECAUSE (VECTOR WE MUST SELECT THE BEST BEING FROM
(INVECTOR (MAPCAR S (QUOTE CAR)))))
(COND ((SINGLETON S)
(SETQ BECAUSE (APPEND BECAUSE (VECTOR AND, TRIVIALLY,
(INVECTOR (CAR S))
IS OUR ONLY CHOICE))))
(T (MAPC (CDR S)
(FUNCTION (LAMBDA (S1)
(COND ((EQUAL T (BETTER S1 BEST))
(SETQ BEST S1))))))))
(SETQ BECAUSE (VECTOR NOW THAT WE HAVE SELECTED (CAR BEST)
AS THE BEST BEING OUT OF THE SET (MAPCAR S (QUOTE CAR))
WE MUST CARRY OUT (INVECTOR BEST)))
(COND ((SETQ TEMPBB (EVAL BEST))
(SETQ UNKNOWN:TASK TEMPBB))
((CDR S)
(CHOOSE:FROM (PULLOUT BEST S)))))
EXPLICIT:ARGS:CHECK (PROGN (SETQ EXP:TEST T)
(MAPC S (FUNCTION (LAMBDA (S1)
(COND ((NOT (EQUAL T (GETP (CAR S1)
BEING)))
(SETQ EXP:TEST NIL))))))
(COND (EXP:TEST)
((EQUAL USER:WARNING:LIST
(SETQ USER:WARNING:LIST
(SETUNION USER:WARNING:LIST
(LIST (VECTOR WARNING, WARNING; NOT
ALL OF
(MAPCAR S (QUOTE CAR))
ARE BEINGS))))))
(T (PUPRINT (CAR (LAST USER:WARNING:LIST))))))
COMPLEXITY:VECTOR (.2 .4 .6 .5 .1)
FAST:COMPLEX .134)
(PUTPROPS CLARIFY:IMPROBABLE:SITUATION BEING T
IMPLICIT:ARGS (WHAT:WE:DID RESPONSE GD1 GD2 L1 L2 L3 EA EAM SPANY2 BC
B:META:CODE WHOLE:CHOICE H1 H2 H3 TCHOICE IXS AN2
AN1 GC2 AN3 IV ANY1:COPY HAN1 HAN2 HAN3)
EXPLICIT:ARGS (U)
EXPLICIT:ARGS:CHECK (COND ((SOME CODING:WARNING:LIST (FUNCTION
(LAMBDA (CWL)
(LESSP (IMPROBABILITY:COMPLEX
CWL)
500)))))
((NULL (CDR CODING:WARNING:LIST)))
(T (SETQ CODING:WARNING:LIST
(MAPCAR CODING:WARNING:LIST
(FUNCTION
(LAMBDA
(COWL)
(CONS (TIMES .8 (
IMPROBABILITY:COMPLEX
COWL))
(CDR COWL))))))
NIL))
WHAT (TUPLE RESOLVE DOUBTS ABOUT A STRANGE AND PROBABLY INCORRECT DETAIL OF
CODE)
HOW (TUPLE IF THE STRANGE PIECE OF CODE IS WRONG, CORRECT IT)
WHY (TUPLE WRONG CODE GIVES WRONG RESULTS; SUCH POOR PERFORMANCE EVENTUALLY
WOULD CAUSE MY DEATH)
WHEN ((CODING:WARNING:LIST 51
(TUPLE BECAUSE THERE IS A KNOWN LIST OF STRANGE
DETAILS, NAMELY (@ CODING:WARNING:LIST)))
(UNDEFINED:SECTION:LIST -40
(TUPLE BECAUSE WE MAY VERY EASILY RESOLVE THE
STRANGENESSES IN THE PROCESS OF DEFINING
THE UNKNOWN FUNCTIONS, SO WE SHOULD DO
THE LATTER FIRST))
(EXECUTABLE:INFO:LIST -200
(TUPLE BECAUSE THERE IS SOMETHING IMMEDIATELY
DO-ABLE, SO WE SHOULD DO IT; IT MAY RESOLVE
SOME STRANGENESSES)))
COMMENTS ((SETQ WHOLE:CHOICE (TRUE:MINIMUM CODING:WARNING:LIST
IMPROBABILITY:COMPLEX))
(SETQ CHOICE (CDR WHOLE:CHOICE))
(SETQ DOING:PUP:LIST (CONS (VECTOR IMPROBABILITY (INVECTOR CHOICE))
DOING:PUP:LIST)))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP WORKED ON SOMETHING
IMPROBABLE, NAMELY (INVECTOR
CHOICE)
,AND HERE IS WHAT WE FINALLY DID
ABOUT IT: (INTUPLE WHAT:WE:DID))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
META:CODE (SETQ
WHAT:WE:DID
(COND
((MATCH (VECTOR IN ALL CODE GENERATED, ANY1 SHOULD BE REPLACED
BY ANY2)
CHOICE)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA
(AL)
(SET AL (DSUBST ANY2 ANY1
(EVAL AL))))))
(MAPC
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(AND (EQUAL (CAR ANY2)
(QUOTE APPEND))
(NOT (LISTP ANY1))
(EQUAL (CAR (SETQ B:META:CODE (GETP B META:CODE)))
STRUCTURE)
(MEMBER ANY1 (FLATTEN B:META:CODE))
(PUT B META:CODE
(MAPCONC B:META:CODE
(FUNCTION
(LAMBDA
(PIECE:OF:CODE)
(COND
((NOT (EQUAL ANY1 (CADDR
PIECE:OF:CODE)))
(LIST PIECE:OF:CODE))
((MAPCAR (CDR ANY2)
(FUNCTION
(LAMBDA (
SUBPIECE:OF:CODE)
(SUBST
SUBPIECE:OF:CODE
ANY1
PIECE:OF:CODE)))))
))))))
(SETQ SPANY2
(COND ((SETQ EAM (MEMBER ANY1 (SETQ EA
(GETP B
EXPLICIT:ARGS))))
(PACK (TUPLE ARG:
(ADD1 (DIFFERENCE (LENGTH
EA)
(LENGTH
EAM))))))
(T ANY2)))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (P)
(COND
((GETP B P)
(PUT B P (DSUBST SPANY2 ANY1
(GETP B P)))))
)))
(AND
(SETQ L1 (CADR (SETQ BC (GETP B META:CODE))))
(MATCH (COMMENT IN ALL CALLS TO DATE, ARG1 IS
INSTANTIATED AS ANY3)
L1)
(EQUAL STRUCTURE (CAR (GETP ANY3 META:CODE)))
(SETQ L2 (MAPCAR (CDR (GETP ANY3 META:CODE))
(QUOTE CADDR)))
(SETQ L3 (SETINTERSECTION L2 ANY2))
(PUT
B META:CODE
(APPEND
(LIST (CAR BC)
(CADR BC))
(COND
((MAPCAR (CDADR (MEMBER (QUOTE ACCESS)
(GETP ANY3 DATA:STRUCTURE)
))
(FUNCTION (LAMBDA
(ACC)
(TUPLE SETQ
(CAR (LAST ACC))
(CADR ACC))))))
(T
(SETQ
CODING:WARNING:LIST
(CONS
(TUPLE
100 VECTOR COMMAND IF
(TUPLE LISTP (TUPLE GETP (@ ANY3)
DATA:STRUCTURE))
(TUPLE
PUT
(@ B)
META:CODE
(TUPLE
SUBST
(TUPLE
APPEND
(TUPLE TUPLE PROGN)
(TUPLE
MAPCAR
(TUPLE
CDADR
(TUPLE MEMBER (TUPLE QUOTE
ACCESS)
(TUPLE GETP
(@ ANY3)
DATA:STRUCTURE)))
(QUOTE
(FUNCTION
(LAMBDA
(ACC)
(TUPLE SETQ
(CAR (LAST ACC))
(CADR ACC)))))))
(COMMENT AT FIRST LOOK, WE DIDNT HAVE
THE ACCESS INFO, SO WE
WAITED TILL LATER TO STICK
IN THESE BINDINGS)
(TUPLE GETP (@ B)
META:CODE))))
CODING:WARNING:LIST))
(QUOTE ((COMMENT AT FIRST LOOK, WE DIDNT HAVE
THE ACCESS INFO, SO WE WAITED
TILL LATER TO STICK IN THESE
BINDINGS)))))
(MAPCAR L3 (FUNCTION (LAMBDA (L4)
(TUPLE COMMENT
(@ L4)
HAD TO BE BOUND
HERE))))
(CDDR BC)))))))
(VECTOR WE REPLACED ALL OCCURRENCES OF (INVECTOR ANY1)
BY
(INVECTOR ANY2)))
((OR (MATCH (VECTOR COMMENT ANY1 IN ANY2 UNDEFINED; WILL BE
GOTTEN LATER; PROBABLY FRAG1 SINCE ANY3)
CHOICE)
(MATCH (VECTOR COMMENT WARNING ANY1 IN ANY2 UNDEFINED; WILL
BE GOTTEN LATER; PROBABLY FRAG1 SINCE ANY3)
CHOICE))
(PUPRIN1 (CONCAT "
MOVE CURSOR TO " ANY1 " WHICH IS LOCATED INSIDE " (GETP ANY2 META:CODE)
"
WHICH IS THE BLOCK OF CODE FOR THE FUNCTION " ANY2))
(COND
((NUMBERP (CAR (LAST (COLON:BREAK ANY2))))
(SETQ H1 ANY1)
(SETQ H2 ANY2)
(SETQ H3 FRAG1)
(SETQ TCHOICE H2)
(PUPRIN1
(CONCAT
"
PUP: WHILE LOOKING OVER SOME POSSIBLE ERRORS IN THE CODE SO FAR,
I NOTICE THAT WE HAVE LEFT " H1 " UNDEFINED. IT IS LOCATED IN
THE FUNCTION " H2 ". IN OTHER WORDS, AT THE INSTANT WE KNOW
THAT " ANY3 "
I SUSPECT THAT THE ANSWER IS " "SOME ELEMENT OF THIS LIST: " H3
".
PLEASE TYPE IN ONE OF THESE, OR ELSE YOUR OWN ANSWER, OR ELSE THE
SINGLE WORD 'DEFER' -- WHICH MEANS 'I AM UNSURE, SO COME BACK TO THIS
LATER.' GO AHEAD NOW
USER: "))
(SETQ RESPONSE (PREAD))
(COND
((EQUAL RESPONSE (QUOTE DEFER))
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3 (IMPROBABILITY:COMPLEX
WHOLE:CHOICE))
CHOICE)))
(VECTOR NOTHING))
((EQUAL H2 GLOBAL:CONTEXT:0)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ GLOBAL:INITIALIZATION:LIST
(CONS (LIST (QUOTE SETQQ)
(SETQ IXS
(COND ((MATCH (TUPLE INITIAL
VALUE OF
FRAG1)
(COLON:BREAK H1))
(COLON:BACK FRAG1))
(T H1)))
RESPONSE)
GLOBAL:INITIALIZATION:LIST))
(VECTOR (INVECTOR IXS)
WILL RECEIVE THE GLOBAL INITIALIZATION VALUE
(INVECTOR RESPONSE)))
((MEMBER RESPONSE H3)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (P)
(COND
((GETP H2 P)
(PUT H2 P (DSUBST
RESPONSE H1
(GETP H2 P))))))))
(SETQ ARG:LIST (GETP H2 EXPLICIT:ARGS))
(VECTOR
WE SUBSTITUTED (@ RESPONSE)
FOR
(@ H1)
THROUGHOUT THE FUNCTION (@ H2)
.BY THE WAY, THIS WAS ONE OF MY SUGGESTIONS!! THE
META:CODE IS (SETQ AN1 (INVECTOR (GETP H2 META:CODE)))
(PROGN (SETQ AN2
(INVECTOR
(PUT H2 META:CODE
(GETCODE (OUTVECTOR (GETP H2
META:CODE))
H2 1))))
(COND ((EQUAL AN1 AN2)
(COMMENT NO FURTHER CHANGES NEED BE MADE
IN THE META:CODE NOW))
(T (APPEND (COMMENT AS YOU KNOW, WE HAD TO
CHANGE THE META:CODE,
WHICH IS NOW)
(LIST AN2)))))))
(T
(SETQ RESPONSE (OUTVECTOR (LIST:TRANSLATE (INVECTOR
RESPONSE)
T)))
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(COND ((EQUAL (LENGTH RESPONSE)
1)
(SETQ RESPONSE (CAR RESPONSE))))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (P)
(COND
((GETP H2 P)
(PUT H2 P
(DSUBST RESPONSE H1
(GETP H2 P)))))))
)
(SETQ ARG:LIST (GETP H2 EXPLICIT:ARGS))
(VECTOR
WE SUBSTITUTED (INVECTOR RESPONSE)
FOR
(INVECTOR H1)
THROUGHOUT THE FUNCTION (@ H2)
.THIS WASN'T WHAT I EXPECTED, BY THE WAY. THE
META:CODE IS (SETQ AN1 (INVECTOR (GETP H2 META:CODE)))
(PROGN (SETQ AN2
(INVECTOR
(PUT H2 META:CODE
(GETCODE (OUTVECTOR (GETP H2
META:CODE))
H2 1))))
(COND ((EQUAL AN1 AN2)
(COMMENT NO FURTHER CHANGES NEED BE MADE
IN THE META:CODE NOW))
(T (APPEND (COMMENT AS YOU KNOW, WE HAD
TO CHANGE THE
META:CODE, WHICH IS
NOW)
(LIST AN2)))))))))
(T (SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(VECTOR DUE TO THE CHARACTER OF (@ ANY2)
,I ASSUME THAT I AM NOT REALLY SUPPOSED TO WORRY
ABOUT THIS EVER.))))
((MATCH (VECTOR ANY1 IS A DATA STRUCTURE, WITH ELEMENTS OF TYPE
ANY2 ;BUT NO ACCESSION INFORMATION IS KNOWN)
CHOICE)
(SETQ H1 ANY1)
(SETQ H2 ANY2)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(COND ((EQUAL (CAR H2)
(QUOTE NOBIND))
(VECTOR I DONT THINK THIS MAKES TOO MUCH SENSE SO I AM
GOING TO SKIP IT -- AT LEAST FOR NOW))
((SATISFY (VECTOR IS STRUCTURE (LIST VECTOR H1 H2)))
(VECTOR ACCESSION ROUTINES NOW EXIST FOR THE DATA
STRUCTURE (@ H1)
;NAMELY,
(GETP H1 DATA:STRUCTURE)))
(T (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3 (CAR WHOLE:CHOICE))
CHOICE)))
(VECTOR WE UNSUCCESSFULLY TRIED TO DEVELOP ROUTINES
FOR ACCESSION TO THE VAGUE DATA STRUCTURE
(@ H1)))))
((MATCH (VECTOR IN ANY1 WE SHOULD TACK ON ANY2)
CHOICE)
(PUPRIN1 (CONCAT "
MOVE CURSOR TO END OF THIS BLOCK OF CODE: " (GETP ANY1 META:CODE)
"
WHICH IS THE CODE FOR THE FUNCTION " ANY1))
(SETQ AN2 ANY2)
(SETQ AN1 ANY1)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(PUT AN1 META:CODE (COPY (NCONC1 (COPY (GETP AN1 META:CODE))
(SETQ GC2
(GETCODE AN2 AN1 -1)))))
(COND ((AND (SETQ AN3 (CAR (LAST AN2)))
(EQUAL (CAR AN3)
(QUOTE QUOTE))
(NOT (INSIDE (CADR AN3)
GLOBAL:INITIALIZATION:LIST))
(SETQ IV (COLON:BACK (TUPLE INITIAL:VALUE:OF
(CADR AN3))))
(NOT (INSIDE IV CODING:WARNING:LIST)))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 144 VECTOR COMMENT WARNING
(@ IV)
IN GLOBAL:CONTEXT:0 UNDEFINED; WILL
BE GOTTEN LATER; PROBABLY NIL SINCE
(COMMENT WE DON'T SEEM TO EVER USE
ANY INITIAL KNOWLEDGE OF
(CADR AN2)
IN ANY CRUCIAL WAY))
CODING:WARNING:LIST))))
(VECTOR WE TACKED ON (INVECTOR GC2)
TO THE METACODE OF THE BEING (@ AN1)))
((MATCH (VECTOR IN ANY1 WE SHOULD REPLACE ANY2 BY ANY3)
CHOICE)
(PUPRIN1 (CONCAT "
MOVE CURSOR TO " ANY2 " WHICH IS LOCATED IN THE BLOCK OF CODE: " (GETP ANY1 META:CODE)
" WHICH IS THE BODY OF THE FUNCTION " ANY1))
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA
(BP)
(PUT ANY1 BP
(COPY (SUBST ANY3 ANY2
(COPY (GETP ANY1 BP))))))))
(VECTOR WE REPLACED (@ ANY2)
BY
(@ ANY3)
IN THE BEING (@ ANY1)))
((MATCH (VECTOR WARNING WE HAVE FOUND NO ANY1 INTO ANY2 DATA
STRUCTURE)
CHOICE)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ GD1 ANY1)
(SETQ GD2 ANY2)
(COND ((SATISFY (VECTOR SOME (@ GD1)
(@ GD2)))
(VECTOR WE KNOW ALL ABOUT THE PRESENCE/ABSENCE/DETAILS
OF THE (@ GD1)
ASSOCIATED WITH THE DATA STRUCTURE (@ GD2)))
(T (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3 (CAR WHOLE:CHOICE))
CHOICE)))
(VECTOR WE TRIED UNSUCCESSFULLY TO WORRY ABOUT THE
FACT THAT THERE AREN'T ANY OBVIOUS
(@ GD1)
W.R.T THE DATA STRUCTURE (@ GD2)))))
((MATCH (VECTOR COMMAND IF ANY1 ANY2)
CHOICE)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(COND ((EVAL ANY1)
(VECTOR SINCE (@ ANY1)
EVALS TO A NONNULL VALUE, WE PERFORMED
(@ ANY2)
,YIELDING THE VALUE (INVECTOR (EVAL ANY2))
,AND ARE FINISHED HERE))
(T (SETQ CODING:WARNING:LIST
(CONS (CONS (TIMES 3 (CAR WHOLE:CHOICE))
(CDR WHOLE:CHOICE))
CODING:WARNING:LIST)))))
((MATCH (VECTOR DELETE ALL MENTION OF ANY1 FROM ALL CODE
GENERATED)
CHOICE)
(SETQ ANY1:COPY ANY1)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC ASSERT:LISTS
(FUNCTION (LAMBDA
(AL)
(SET AL (MAPCONC AL
(FUNCTION
(LAMBDA
(PAL)
(COND
((MEMBER ANY1:COPY
(FLATTEN
PAL))
NIL)
(T (LIST PAL))))))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND
((LISTP (GETP B META:CODE))
(PUT B META:CODE
(CAR (OUTFORM ANY1:COPY
(GETP B META:CODE)
))))))))
(VECTOR WE DELETED ALL MENTION OF (@ ANY1:COPY)
FROM ALL THE BEINGS CODES))
((MATCH (VECTOR INFINITE LOOP IN ANY1 FROM ANY2 TO ANY3)
CHOICE)
(PUPRIN1
(CONCAT
"
MOVE CURSOR BACK AND FORTH OVER THE INFINITE LOOP FROM " ANY2 " TO " ANY3 " IN THE BLOCK OF CODE: " (GETP ANY1
META:CODE)
" WHICH IS THE BODY
OF THE FUNCTION " ANY1))
(SETQ HAN1 ANY1)
(SETQ HAN2 ANY2)
(SETQ HAN3 ANY3)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(PUT
HAN1 META:CODE
(SUBST
(GETCODE
(PROGN
(PUPRIN1
"
AT THE END OF THIS BLOCK, WE'LL PUT IN SOMETHING LIKE THIS: ")
(TERPRI)
(TUPLE COND (LIST (LIST IS:OF:TYPE (QUOTE ARG1)
(COMMENT BREAKAWAY))
(COMMENT FINALIZATION OF LOOP
STARTING AT (@ HAN2)
MAY GO HERE))
(LIST T (OUTVECTOR HAN3))))
HAN1 0)
(OUTVECTOR HAN3)
(COPY (GETP HAN1 META:CODE))))
(VECTOR INFINITE LOOP TERMINATION DECISION IS ABOUT TO BE
INVESTIGATED, I BETCHA!!!))
(T (SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST (NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3
(
IMPROBABILITY:COMPLEX WHOLE:CHOICE))
CHOICE)))
(VECTOR NOTHING, SINCE I COULDNT UNDERSTAND IT))))
FAST:COMPLEX .14)
(PUTPROPS CLASSIFICATORY:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN HOW TO DISTINGUISH NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION OF THE DOMAIN OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS COMPARE BEING T
EXPLICIT:ARGS (POSSIBLE:OBJECT IDEAL:OBJECT)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE COMPARE (@ POSSIBLE:OBJECT)
WITH
(@ IDEAL:OBJECT))
HOW (TUPLE BY APPLYING A FUNCTION (TUPLE PROBABLY ALREADY KNOWN)
TO EITHER THESE TWO OBJECTS, OR ELSE TO THEIR CORRESPONDING PARTS.)
WHY (TUPLE PUP WANTS TO SEE IF (@ POSSIBLE:OBJECT)
IS CLOSE ENOUGH TO (@ IDEAL:OBJECT))
META:CODE (COMMENT DEPENDS UPON THE PARTICULAR FLAVOR OF COMPARISON)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE TEST)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(TUPLE PROGN (VECTOR COMPARING MAY INVOLVE A FUNCTION APPLIED DIRECTLY TO THE
TWO ARGUMENTS)
(VECTOR COMPARING MAY INVOLVE APPLYING A FUNCTION TO CORRESPONDING PAIRS
OF SUBPARTS OF THE OBJECTS, AND FINALLY JOINING TOGETHER ALL
THESE SUB-COMPARISONS' RESULTS)
(QUOTE (PROGN (SETQ H1 (HIGHLY:STRUCTURED ARG1))
(SETQ H2 (HIGHLY:STRUCTURED ARG2))
(SETQ C12 (STRUCTURE:COMPATIBLE ARG1 ARG2))
(COND ((AND H1 H2 C12)
NIL)
((AND H1 H2)
(ERROR))
((OR H1 H2)
NIL)
(T T)))))
AFFECTS
(VECTOR THE COMPARE ALGORITHM)
RESULTS
(VECTOR
(QUOTE (COND ((SETQ SA (CADR (SETQ SC (SASSOC (CADR CHOICE)
LOOP:TERMINATION:LIST))))
(COND ((MEMBER SA PRIMITIVE:VARS:LIST)
(VECTOR PROGN ARG1 ARG2
(COMMENT THE PRESENCE OF ARG1 AND ARG2 ABOVE
DOES NO HARM; IT IS NECESSARY SOMEWHERE
IN THE FUNCTION SO THAT PUP WILL INSERT
COMMENTS ABOUT WHAT ARG1 AND ARG2 GET
INSTANTIATED AS.)
(COMMENT SINCE THIS COMPARISON PREDICATE MUST
ALWAYS RETURN THE CONSTANT VALUE
(@ SA)
,ALL THAT (CADR CHOICE)
CAN POSSIBLY BE IS A SEQUENCE OF
ASSIGNMENTS, REWRITES, AND ITERATIVE
STATEMENTS, ENDING WITH (@ SA))
(@ SA)))
(T (SETQ SB (CADR SA))
(VECTOR PROGN
(COMMENT HERE WE MAY LATER WANT TO PUT SOME
ASSIGNMENTS, REWRITES, AND ITERATIVE
STATEMENTS)
(VECTOR COND (VECTOR (VECTOR NOT (INVECTOR
SB))
(CADDR SC))
(INVECTOR (CADDDR SC)))))))
(T (VECTOR JOINING:FUNCTION ARG1 ARG2))))
(QUOTE
(VECTOR
PROGN ARG1 ARG2
(COMMENT ARG1 AND ARG2 ARE HERE SIMPLY TO CAUSE PUP TO STICK IN COMMENTS
ABOUT THEIR INSTANTIATION)
(APPEND
(VECTOR JOINING:FUNCTION)
(COND
((HIGHLY:STRUCTURED ARG1)
(MAPCAR (CDR (GETP ARG1 META:CODE))
(FUNCTION (LAMBDA (PARTICLE HOLD:ANY1 SECOND:OBJ)
(SETQ HOLD:ANY1 (CAR PARTICLE))
(MAPC TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF
(CONS VECTOR
PARTICLE)
FRAG1)
TOL)
(SETQ HOLD:ANY1 ANY1))))))
(SETQ SECOND:OBJ
(SUBST ARG2 (CAR (COLON:BREAK ARG1))
(COPY (COLON:BREAK HOLD:ANY1))
))
(SETQ SECOND:OBJ
(COND
((MEMBER ARG2 SECOND:OBJ)
SECOND:OBJ)
(T (APPEND SECOND:OBJ
(LIST (QUOTE OF)
ARG2)))))
(COND
((NUMBERP (CAR (LAST SECOND:OBJ)))
(SETQ
SECOND:OBJ
(REVERSE (CONS (SETQ NEW:F:NUMBER
(ADD1
NEW:F:NUMBER))
(CDR (REVERSE
SECOND:OBJ)))))
))
(SETQ SECOND:OBJ (COLON:BACK SECOND:OBJ))
(LIST VECTOR COMPARE HOLD:ANY1 SECOND:OBJ))
)))
((HIGHLY:STRUCTURED ARG2)
(SETQ SSTRUC (STRUCTURE))
(SETQ TSTRUC (STRUCTURE))
(SETQ
FRESULT
(MAPCAR
(CDR (GETP ARG2 META:CODE))
(FUNCTION
(LAMBDA
(PARTICLE HOLD:ANY1 FIRST:OBJ)
(SETQ HOLD:ANY1 (CAR PARTICLE))
(MAPC TYPE:OF:LIST (FUNCTION
(LAMBDA (TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF
(CONS VECTOR PARTICLE)
FRAG1)
TOL)
(SETQ HOLD:ANY1 ANY1))))))
(SETQ FIRST:OBJ (SUBST ARG1 (CAR (COLON:BREAK ARG2))
(COPY (COLON:BREAK HOLD:ANY1))))
(COND ((NUMBERP (CAR (LAST FIRST:OBJ)))
(SETQ FIRST:OBJ (REVERSE (CONS (SETQ NEW:F:NUMBER
(ADD1
NEW:F:NUMBER))
(CDR (REVERSE
FIRST:OBJ)))))
))
(SETQ FIRST:OBJ (COND ((MEMBER ARG1 FIRST:OBJ)
FIRST:OBJ)
(T (APPEND FIRST:OBJ
(LIST (QUOTE OF)
ARG1)))))
(SETQ FIRST:OBJ (COLON:BACK FIRST:OBJ))
(SETQ TSTRUC (NCONC1 TSTRUC (APPEND (LIST (CAR PARTICLE)
(CADR PARTICLE)
FIRST:OBJ)
(CDDDR PARTICLE))))
(SETQ SSTRUC (NCONC1 SSTRUC (APPEND (LIST (CAR PARTICLE)
(CADR PARTICLE)
HOLD:ANY1)
(CDDDR PARTICLE))))
(SETQ
D1
(VECTOR
ONETYPE
(VECTOR THIS IS MORE OF A FIXUP THAN A DECISION: WHAT WE
ARE DOING IS TO REPLACE (@ FIRST:OBJ)
BY ITS RIGHTFUL ACCESSION CALL, NOW THAT
(@ ARG1)
HAS ITS DATA:STRUCTURE ANSWER MASTERED)
RESULTS
(TUPLE
PROGN
(TUPLE
SOME
(TUPLE CADR (TUPLE MEMBER (TUPLE QUOTE ACCESS)
(TUPLE GETP (@ ARG1)
DATA:STRUCTURE)))
(TUPLE
FUNCTION
(TUPLE
LAMBDA
(TUPLE W)
(TUPLE AND (TUPLE EQUAL
(TUPLE APPEND
(TUPLE COLON:BREAK
(TUPLE CDDR W))
(TUPLE TUPLE OF)
(TUPLE COLON:BREAK
(@ ARG1)))
(TUPLE COLON:BREAK
(@ FIRST:OBJ)))
(TUPLE SETQ W1
(TUPLE COPY
(TUPLE SUBST (TUPLE QUOTE
ARG1)
(TUPLE QUOTE X)
(TUPLE COPY
(TUPLE CAR W))
)))))))
W1)
FIXUP))
(SETQ SITU1 (TUPLE LISTP (TUPLE GETP (@ ARG1)
DATA:STRUCTURE)))
(SETQ DEFERRED:DECISION:LIST (CONS (VECTOR (@ D1)
UNTIL
(@ SITU1))
DEFERRED:DECISION:LIST))
(LIST VECTOR COMPARE FIRST:OBJ
(COND ((SOME (CADR (MEMBER (QUOTE ACCESS)
(GETP ARG2 META:CODE)))
(FUNCTION (LAMBDA
(W)
(AND (MATCH (TUPLE ANY1
ACCESSES
ANY3)
W)
(EQUAL HOLD:ANY1
(COLON:BACK
ANY3))))))
(COPY (SUBST (QUOTE ARG2)
(QUOTE X)
(COPY ANY1))))
(T HOLD:ANY1)))))))
(PUT ARG2 META:CODE SSTRUC)
(COND ((GETP ARG1 BEING)
(PUT ARG1 META:CODE TSTRUC))
(T (SET ARG1 ARG1)
(SETQ CODE TSTRUC)
(SETQ BNAME ARG2)
(SETQ FNAME ARG1)
(SATISFY (VECTOR IS BEING FNAME))))
FRESULT))))))
COMPARE)
(VECTOR ALTERNATIVES (VECTOR NOMINAL:RESULT ORDINAL:RESULT RATIO:RESULT
VECTOR:RESULT)
AFFECTS
(VECTOR THE TERMINATION CHARACTERISITCS OF THE COMPARING)
WHEN
(VECTOR BEFORE THE COMPARING ROUTINE IS FINALIZED)
COMPARE))
PREDICATE T
FAST:COMPLEX .14)
(PUTPROPS COMPARITIVE:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN TO DISTINGUISH AND RANK NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION AND AN ORDERING OF THE RESULTANT
SUBSETS OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS COMPLEX:ALTERATION BEING T
EXPLICIT:ARGS (S)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ALTER (@ S)
AND/OR ANOTHER ELEMENT OF THE SAME OUTER LIST)
HOW (TUPLE BY MODIFYING THE STRUCTURE OF SUCH AN ELEMENT)
WHY (TUPLE BECAUSE MODIFYING THE STRUCTURE OF AN INDIVIDUAL ELEMENT IS EQUIVALENT TO
UPDATING OUR DESCRIPTION OF A SINGLE PARTICULAR CONCEPT, AND THIS IS
FUNDAMENTAL TO A DECENT CONCEPT FORMATION PROGRAM)
META:CODE (VECTOR DEPENDS ON WHAT THE USER WANTS DONE)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR
(VECTOR
ONETYPE
(VECTOR WE PUT IN A 'MODIFY:STRUCTURE' CALL FOR EACH SUBPART OF
ARG1, SO NO DECISION NEED BE MADE HERE: THE MODIFY:STRUCTURE
BEINGS ALWAYS MAKE A DECISION THEMSELVES)
AFFECTS
(VECTOR THE COMPLEX:ALTERATION ALGORITHM)
RESULTS
(APPEND
(VECTOR PROGN)
(PROGN (SETQ PS
(COND ((MATCH (TUPLE P O S S I B L E : FRAG1)
(UNPACK ARG1))
ARG1)
(T (PACK (LIST (QUOTE POSSIBLE:)
ARG1)))))
(SETQ SPS (PACK (LIST (QUOTE SET:OF:)
(PLURAL PS))))
(COND ((AND (MEMBER PS IS:STRUCTURE:LIST)
(NOT (MEMBER ARG1 IS:STRUCTURE:LIST)))
(COND ((NULL (GETP ARG1 BEING))
(SETQ BNAME PS)
(SETQ FNAME ARG1)
(SETQ CODE (GETP PS META:CODE))
(SATISFY (VECTOR IS BEING FNAME))))
(PUT ARG1 DATA:STRUCTURE (SUBST ARG1 PS
(COPY (GETP PS
DATA:STRUCTURE))))
(MAPC CODING:WARNING:LIST
(FUNCTION
(LAMBDA
(CW)
(COND
((AND (MATCH (TUPLE ANY1 VECTOR COMMENT
ANY2 IN
(@ PS)
UNDEFINED; WILL BE
GOTTEN LATER; FRAG1)
CW)
(MEMBER ANY2 (FLATTEN
(GETP ARG1
DATA:STRUCTURE))))
(SETQ
CODING:WARNING:LIST
(CONS (SUBPAIR (LIST PS ANY1)
(LIST ARG1
(SUB1 ANY1))
(COPY CW)
T)
CODING:WARNING:LIST)))))))
(MAPC (MAPCAR (CDR (GETP PS META:CODE))
(QUOTE CADDR))
(FUNCTION
(LAMBDA
(PROP)
(COND ((GETP PROP BEING)
(PUT PROP DATA:STRUCTURE
(APPEND (GETP PROP
DATA:STRUCTURE)
(LIST (QUOTE ALTERNATE)
ARG1 PS))))))))
(SETQ IS:STRUCTURE:LIST (CONS ARG1 IS:STRUCTURE:LIST)
)))
(SATISFY IS STRUCTURE (LIST VECTOR SPS PS))
(MAPCAR (CDADR (MEMBER (QUOTE ACCESS)
(GETP ARG1 DATA:STRUCTURE)))
(FUNCTION (LAMBDA (ACC)
(VECTOR SETQ (CAR (LAST ACC))
(CADR ACC))))))
(MAPCONC
(CDR (GETP ARG1 META:CODE))
(FUNCTION
(LAMBDA
(PARTICLE)
(PUPRIN1
(CONCAT
"
WE MIGHT WANT TO MODIFY HERE THE SUBPART " PARTICLE " OF THE ELEMENT " ARG1 " OF THE DATA STRUCTURE " SPS
"? PLEASE ANSWER YES OR NO, NOTICING
THAT 'YES' ALSO ENCOMPASSES 'MAYBE' IN THIS CASE.
USER: "))
(COND
((EQUAL (PREAD)
(QUOTE NO))
(PUPRIN1
"
OK, SO WE DON'T PUT IN ANY CORRESPONDING FUNCTION CALL HERE
")
NIL)
(T
(PUPRIN1
"
SO WE DO PUT IN THE CORRESPONDING FUNCTION CALL HERE.
")
(LIST (VECTOR MODIFY:STRUCTURE (CADDR PARTICLE)
(LIST (QUOTE QUOTE)
ARG1))))))))
(COND ((AND (NOT (EQUAL ARG1 PS))
(FLOW:PRECEDED (VECTOR SET (@ PS)
FRAG1))
(PUPRIN1 (CONCAT "
SHOULD I ALTER BOTH " ARG1 " AND " PS " AT THIS POINT?
USER: "))
(MEMBER (PREAD)
(TUPLE Y T YES MAYBE)))
(LIST (VECTOR COMPLEX:ALTERATION (@ PS))))))
COMPLEX:ALTERATION))
FAST:COMPLEX .14)
(PUTPROPS COMPLEX:COMPARE:FN BEING T
EXPLICIT:ARGS:CHECK T
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(QUOTE (VECTOR (VECTOR THE STANDARD LEXICOGRAPHIC
ALPHANUMERIC ORDERING)
(VECTOR SOME ORIGINAL, MORE COMPLEX
ORDERING FUNCTION)
(ERROR!)))
AFFECTS
(VECTOR THE COMPLEX:COMPARE:FN ALGORITHM)
RESULTS
(VECTOR (VECTOR PROGN
(COMMENT THIS ALLOWS MERGE TO BE THE
SAME AS ALPHORDER)
(PROG1 (VECTOR ALPHORDER ARG1 ARG2)
(SETQQ ALPHORDER ALPHORDER)
(SETQ GLOBAL:INITIALIZATION:LIST
(CONS (TUPLE SETQQ
ALPHORDER
ALPHORDER)
GLOBAL:INITIALIZATION:LIST))))
(VECTOR PROGN
(COMMENT THIS ALLOWS MERGE TO BE VERY
COMPLEX INDEED)
(VECTOR LEARN:BY:EXAMPLE
(VECTOR COMPARE ARG1 ARG2))))
COMPLEX:COMPARE:FN))
FAST:COMPLEX 1.0)
(PUTPROPS COMPLEX:MODIFY:STRUCTURE BEING T
EXPLICIT:ARGS (ARG1 ARG2 ARG3)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE WE DECIDE ON THE FORMAT OF THE MODIFICATION TO BE DONE)
HOW (TUPLE BY TAKING ONE PATH OF THE MODIFY/MAP-MODIFY DICHOTIC PATH)
WHY (TUPLE BECAUSE THE FORM OF EACH TYPE OF MODIFY IS VERY DIFFERENT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR MIGHT THE MODIFICATION DEPEND UPON THE RESULTS --
PRESULT -- OF OUR GUESS AND ON SOME PARTS OF THE INPUT
-- ELEMENT -- AS WELL AS DEPENDING ON THE TRUE CLASS
NAME -- NAME:OF:CLASS ?????)
AFFECTS
(VECTOR THE COMPLEX:MODIFY:STRUCTURE ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF
(INVECTOR (LAST (CADR D)))
IS
(VECTOR MODIFY:STRUCTURE ARG1)
AND IS USED IN
(GET:USAGE (CADR CHOICE)
COMPLEX:MODIFY:STRUCTURE))
TYPE:OF:LIST))))
YES:RESULTS
(QUOTE
((PROGN
(SETQ
TYPE:OF:LIST
(CONS
(VECTOR
(CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(VECTOR
NLSETQ
(VECTOR
EVAL
(VECTOR
TUPLE APPLY* (VECTOR COLON:BACK
(VECTOR LIST ARG1 ARG3
(VECTOR QUOTE
MODIFY:STRUCTURE)))
(SETQ
PA
(INVECTOR
(COND
((AND
(SETQ A2ACC
(CADR (MEMBER (QUOTE ACCESS)
(GETP ARG2
DATA:STRUCTURE))))
(SOME
(CDR (GETP (EVAL ARG2)
META:CODE))
(FUNCTION
(LAMBDA
(MC)
(SETQ ARES MC)
(NOT (INSIDE (QUOTE NAME)
MC)))))
(SOME
A2ACC
(FUNCTION
(LAMBDA
(AA)
(MATCH (TUPLE ANY1 ACCESSES
(@ ARES))
AA))))
(CONS TUPLE
(COPY (SUBST (QUOTE ARG2)
(QUOTE X)
(COPY ANY1))))))
(T (VECTOR TUPLE SOME:PART:OF ARG2)))))
(VECTOR TUPLE QUOTE SET:OF:RULES))))
AND IS USED IN (GET:USAGE (CADR CHOICE)
COMPLEX:MODIFY:STRUCTURE))
TYPE:OF:LIST))
(SATISFY (VECTOR IS CONSTRAINED (SETQQ
SET:OF:POSSIBLE:NAMES:OF:CLASS
SET:OF:POSSIBLE:NAMES:OF:CLASS)))
(SETQ
TRUE:FN:CALL:LIST
(APPEND
TRUE:FN:CALL:LIST
(MAPCONC
(SETQ CL (CADR (SASSOC (QUOTE
SET:OF:POSSIBLE:NAMES:OF:CLASS)
IS:CONSTRAINED:LIST)))
(FUNCTION
(LAMBDA
(PN1)
(MAPCAR
CL
(FUNCTION
(LAMBDA
(PN2)
(SETQ PN (COLON:BACK (LIST PN1 PN2
(QUOTE
MODIFY:STRUCTURE))))
(SETQ
CODING:WARNING:LIST
(NCONC1
CODING:WARNING:LIST
(TUPLE
101 VECTOR IN (@ PN)
WE SHOULD TACK ON
(TUPLE
CONDITIONAL:INSERTION ARG1
(TUPLE
QUOTE
(PACK (TUPLE SET:OF:
(@ PN1)
:STRINGS)))))))
(SETQ TRUE:FN:CALL:LIST
(CONS (LIST PN PA (TUPLE QUOTE
SET:OF:RULES))
TRUE:FN:CALL:LIST))
(LIST PN PA (TUPLE QUOTE SET:OF:RULES)))))
))))))))
BOTH:RESULTS
(QUOTE ((SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
COMPLEX:MODIFY:STRUCTURE))
FAST:COMPLEX .14)
(PUTPROPS CONCEPT:FORMATION BEING T
IDEN (((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION)))
WHAT (TUPLE LEARN HOW TO IMPOSE A CONCEPT STRUCTURING UPON A DOMAIN; LEARN HOW TO
CHARACTERIZE, OR AT LEAST DISTINGUISH, VARIOUS CONCEPTS)
HOW (TUPLE BY CHOOSING THE DESIRED TYPE OF CONCEPT FORMATION CALLED FOR, AND THEN
CARRYING IT OUT)
WHY (TUPLE CONCEPT:LEARNING IS NECESSARY TO CONCEPT KNOWLEDGE)
WHEN (((MEMBER TYPE:OF:C:F ABLE:PUP:LIST)
-70
(TUPLE BECAUSE IF WE CAN ALREADY DO (@ TYPE:OF:C:F)
THEN WE SHOULDNT TRY TO DO IT OVER AGAIN))
((MEMBER (QUOTE (CHARACTERIZE CLASSES))
PUP:WANTS:LIST)
88
(QUOTE (BECAUSE CONCEPT FORMATION IS A GOOD WAY TO GET A CHARACTERIZATION OF
CLASSES)))
(T (COND (NEW:INFO:LIST -60)
(T 40))
(QUOTE (BECAUSE NEW INFORMATION MIGHT ALTER OUR COURSE OF ACTION))))
META:CODE (EVAL (LIST TYPE:OF:C:F))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WORK ON CONCEPT FORMATION))
(VECTOR AWARE USER
(VECTOR THE TYPE OF CONCEPT FORMATION PUP IS ABOUT TO WORK ON IS
(@ TYPE:OF:C:F))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP HAS THOUGHT ABOUT THE (@ TYPE:OF:C:F)
TYPE OF CONCEPT:FORMATION)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE INFERENCE:DEMONS ATTENTION:DEMONS)
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION)))
AFFECTS (TUPLE (TUPLE (EVAL TYPE:OF:C:F)
CALLED))
COMPLEXITY:VECTOR (.1 .5 .5 .5 .1)
GENERALIZATIONS (ATTEND LEARN INDUCTIVE:INFERENCE)
SPECIALIZATIONS (VECTOR (VECTOR ALTERNATIVES (VECTOR CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION
METRICAL:CONCEPT:FORMATION)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR CONCEPTS MAY VARY WITH TIME)
AFFECTS
(VECTOR THE BASIC STRUCTURE OF FORMING A CONCEPT)
CONCEPT:FORMATION)
(VECTOR BOOLEAN
(VECTOR CONCEPT FORMATION MAY DEPEND UPON THE SPEED OF
PRESENTATION OF THE STIMULI)
AFFECTS
(VECTOR THE AMOUNT OF EFFORT (@ TASK:NAME)
SHOULD SPEND ON IDENTIFYING EACH STIMULUS)
CONCEPT:FORMATION)
(VECTOR DICHOTOMY
(VECTOR (VECTOR INSTANCES MAY BE LEFT IN VIEW
INDEFINITELY)
(VECTOR INSTANCES MAY BE REMOVED AFTER PROCESSING)
)
RESULTS
(VECTOR (VECTOR NEW RELATIONS CAN BE DERIVED AS NEEDED)
(VECTOR ALL RELATIONS MUST BE DERIVED UPON
INITIAL EXPOSURE TO THE STIMULUS))
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO GET RELATIONS FROM
INPUT STIMULI)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR CONJUNCTIVE:CONCEPT:FORMATION
DISJUNCTIVE:CONCEPT:FORMATION
MIXED:CONJUNCTIVE:AND:DISJUNCTIVE:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW (@ TASK:NAME)
STORES THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:TRANSFER:CONCEPT:FORMATION
NEGATIVE:TRANSFER:CONCEPT:FORMATION
NO:TRANSFER:CONCEPT:FORMATION
POSITIVE:AND:NEGATIVE:TRANSFER:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW PREVIOUSLY:LEARNED CONCEPTS AND
PREVIOUSLY:ENCOUNTERED STIMULI AFFECT THE
LEARNING OF NEW CONCEPTS AND THE RECOGNITION THAT
A NEW CONCEPT IS NEW)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO SEARCH THROUGH THE
SET OF CONCEPTS)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:INSTANCE:UTILIZATION
NEGATIVE:INSTANCE:UTILIZATION
POSITIVE:AND:NEGATIVE:INSTANCE:UTILIZATION)
AFFECTS
(VECTOR WHAT INFORMATION (@ TASK:NAME)
MAY USE TO MODIFY THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
OF (@ TASK:NAME))
AFFECTS
(VECTOR WHETHER PARAMETERS DESCRIBING AN INDIVIDUAL MUST
BE PREAD IN BY (@ TASK:NAME))
WHEN
(VECTOR BEFORE ANY ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE ANY PROCESSING ROUTINE MAY HAVE TO DEPEND
UPON SOME INDIVIDUAL PARAMETERS)
CONCEPT:FORMATION)
(VECTOR ADAPTATION (VECTOR DESIRED DIALOGUE BETWEEN (@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT DETAILS)
CONCEPT:FORMATION))
ALTERNATIVES ((GRAMMATICAL:INFERENCE PATTERN:RECOGNITION SIMULATED:EVOLUTION))
FAST:COMPLEX .136)
(PUTPROPS CONDITIONAL:DELETION EXPLICIT:ARGS (E S)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE PERHAPS WE WILL STICK IN A CONDITIONAL DELETION STATEMENT, STICKING IN AN
(@ E)
-TYPE ELEMENT INTO ITS PARENT STRUCTURE)
HOW (TUPLE WE WILL ASK THE USER, PROBABLY)
WHY (TUPLE BECAUSE IF AN DELETION IS NOT TO BE MADE, THEN WE WANT TO WIPE OUT ALL
TRACES OF THIS STATEMENT; IF ONE IS TO BE MADE, WE WILL NEED THE USER TO
GUIDE US SINCE THE DETAILS HERE DEPEND CRITICALLY UPON THE DETAILS HE HAS
IN MIND FOR THE PROGRAM)
META:CODE (VECTOR WE ASK THE USER)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE MODIFY:STRUCTURE)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR DO I, AT THIS POINT, CONDITIONALLY DELETE
(COND ((AND ARG2 (NOT (EQUAL (QUOTE NOBIND)
(CAR (QUOTE DSMATCH)))))
(SETQ PS DSN)
(SETQ SPS (COND ((ATOM ARG2)
ARG2)
(T (EVAL ARG2))))
ARG1)
(T (SETQ PS
(COND ((MATCH (TUPLE P O S S I B L E :
FRAG1)
(UNPACK ARG1))
ARG1)
(T (PACK (LIST (QUOTE POSSIBLE:)
ARG1)))))
(SETQ SPS (PACK (LIST (QUOTE SET:OF:)
(PLURAL PS))))
(COND ((AND ARG1 (ATOM ARG1))
(SET SPS SPS)
(SET ARG1 ARG1)
(SET PS PS)
(SATISFY (VECTOR IS STRUCTURE
(LIST VECTOR SPS PS)))
(COND ((AND (MEMBER ARG1 IS:STRUCTURE:LIST)
(NOT (MEMBER (LIST VECTOR SPS
PS)
IS:STRUCTURE:LIST)
))
(SETQ PS (VECTOR I:DONT:KNOW:WHAT))
(SETQ SPS ARG1)
(SETQ ARG1
(COLON:BACK
(CDDR (COLON:BREAK ARG1)))))
(T ARG1)))
(T (SETQQ PS ARG1)
(SETQQ SPS (EVAL ARG2))
ARG1))))
,OR A SIMILAR ELEMENT, INTO THE DATA STRUCTURE
(@ SPS)
??? PLEASE RESPOND YES OR NO; IF YOU SAY 'YES', THEN I
WILL PROBABLY HAVE TO ASK YOU SOME MORE QUESTIONS.)
AFFECTS
(VECTOR THE CONDITIONAL:DELETION ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ CODING:WARNING:LIST
(CONS (TUPLE 10 VECTOR DELETE ALL MENTION OF
(CADR CHOICE)
FROM ALL CODE GENERATED)
CODING:WARNING:LIST))))
BOTH:RESULTS
(QUOTE ((VECTOR NOTHING IN COMMON)))
YES:RESULTS
(QUOTE
((PUPRIN1
"
NOW WE MUST KNOW 2 THINGS:
(1) WHAT WE DELETE
(2) UNDER WHAT CONDITION WE DO THE DELETION
NOTES ABOUT (1): IF WE ARE DELETING AN ALREADY EXISTING THING, THEN
JUST GIVEITS NAME; IF IT IS NEW, GIVE AN EXPRESSION INDICATING HOW WE
GET IT, PERHAPS IN TERMS OF ARG1.
")
(PUPRINT (TUPLE RECALL THAT HERE, ARG1 IS INSTANTIATED AS
(@ ARG1)))
(PUPRIN1
"
NOTES ABOUT (2): YOU MAY REFER TO THE RESULT OF (1) AS ")
(PUPRIN1 (SETQ RS (PACK (TUPLE RESULT: (SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(PUPRIN1
", IF (1) IS
NOT SIMPLY AN OLD NAME.
ALSO, WE ASSUME THAT PART OF THE CONDITION (2) IS THE FACT THAT ")
(PUPRINT RS)
(PUPRIN1
" IS NOT ALREADY IN THE LIST. THIS NEED NOT BE
RESTATED BY THE USER.
TYPING SIMPLY ']' WILL CAUSE ME TO ASSUME YOU WANT THE CONDITION:
")
(PUPRINT (LIST RS (QUOTE ISNT)
NIL))
(PUPRIN1 "
USER: (1) : ")
(SETQ RESULTANT (LIST:TRANSLATE (INVECTOR (PREAD))
T))
(PUPRIN1 "
USER: (2): ")
(SETQ CONDIT (COND ((LIST:TRANSLATE (INVECTOR (PREAD))
T))
(RS)))
(COND ((EQUAL (CADR RESULTANT)
(QUOTE AND))
(SETQ RESULTANT (APPEND (VECTOR LIST:JOIN)
(CDDR RESULTANT)))))
(SETQ HTAL (CADR (MEMBER (QUOTE ACCESS)
(GETP ARG1 DATA:STRUCTURE))))
(SETQ TAL (COND ((LISTP HTAL)
(CDR HTAL))))
(SETQ RESULTANT (SUBPAIR (MAPCAR TAL (FUNCTION
(LAMBDA (A)
(CAR (LAST A)))))
(MAPCAR TAL (FUNCTION (LAMBDA
(A2)
(CDADR A2))))
(COPY RESULTANT)
T))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA
(TOL)
(MATCH (VECTOR (CADR CHOICE)
TYPE OF
(VECTOR
CONDITIONAL:DELETION)
IS FRAG1 USED IN
ANY2)
TOL))))
(SETQ OANY2 ANY2)
(SETQ
TYPE:OF:LIST
(CONS
(VECTOR
(CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(VECTOR
PROGN
(VECTOR SETQ (@ RS)
(INVECTOR RESULTANT))
(VECTOR
COND
(VECTOR
(INVECTOR CONDIT)
(PROGN
(SETQ
TSUB
(SUBST
RS
(QUOTE X)
(CADDAR (OUTVECTOR
(CADR (MEMBER (QUOTE DELETE)
(GETP SPS
DATA:STRUCTURE)))))
))
(COND
((EQUAL PS (QUOTE ARG1))
(VECTOR (COND ((EQUAL (CAR SPS)
(QUOTE EVAL))
(QUOTE SET))
(T (QUOTE SETQ)))
(COND ((MATCH (TUPLE EVAL ANY3)
SPS)
ANY3)
(T SPS))
(VECTOR SETDIFFERENCE (@ SPS)
(COND
((ATOM RESULTANT)
(VECTOR LIST (@ RESULTANT)))
((MEMBER
(CADR (INVECTOR RESULTANT)
)
(VECTOR MAPCAR MAPCONC
LIST TUPLE APPEND
CONS
SETDIFFERENCE
SETINTERSECTION
SETUNION NCONC1))
RS)
(T (LIST VECTOR
(QUOTE LIST)
RS))))))
((AND ARG2 (EQUAL (EVAL ARG2)
(SETQ
TS2
(CADR (MEMBER (QUOTE
ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))))
)
(SUBST TS2 (CADDR (MEMBER (QUOTE ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))
TSUB))
(T TSUB))))
(VECTOR T (VECTOR SETQ (@ RS)
NIL))))
AND IS USED IN (@ OANY2))
TYPE:OF:LIST))
(SETQ SOME:DELETIONS:LIST (CONS (CADR CHOICE)
SOME:DELETIONS:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
CONDITIONAL:DELETION))
BEING T
IDEN (((@ (@ (@ (EQUAL (CAR LI)
(QUOTE DELETE)))))
(VECTOR CONDITIONAL:DELETION (TRANSLATE (INVECTOR (CDR LI))
T))))
FAST:COMPLEX .14)
(PUTPROPS CONDITIONAL:INSERTION BEING T
EXPLICIT:ARGS (E S)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE PERHAPS WE WILL STICK IN A CONDITIONAL INSERTION STATEMENT, STICKING IN
AN (@ E)
-TYPE ELEMENT INTO ITS PARENT STRUCTURE)
HOW (TUPLE WE WILL ASK THE USER, PROBABLY)
WHY (TUPLE BECAUSE IF AN INSERTION IS NOT TO BE MADE, THEN WE WANT TO WIPE OUT ALL
TRACES OF THIS STATEMENT; IF ONE IS TO BE MADE, WE WILL NEED THE USER TO
GUIDE US SINCE THE DETAILS HERE DEPEND CRITICALLY UPON THE DETAILS HE HAS
IN MIND FOR THE PROGRAM)
META:CODE (VECTOR WE ASK THE USER)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE MODIFY:STRUCTURE)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR DO I, AT THIS POINT, CONDITIONALLY INSERT
(COND ((AND ARG2 (NOT (EQUAL (QUOTE NOBIND)
(CAR (QUOTE DSMATCH)))))
(SETQ PS DSN)
(SETQ SPS (COND ((ATOM ARG2)
ARG2)
(T (EVAL ARG2))))
ARG1)
(T (SETQ PS
(COND ((MATCH (TUPLE P O S S I B L E :
FRAG1)
(UNPACK ARG1))
ARG1)
(T (PACK (LIST (QUOTE POSSIBLE:)
ARG1)))))
(SETQ SPS (PACK (LIST (QUOTE SET:OF:)
(PLURAL PS))))
(COND ((AND ARG1 (ATOM ARG1))
(SET SPS SPS)
(SET ARG1 ARG1)
(SET PS PS)
(SATISFY (VECTOR IS STRUCTURE
(LIST VECTOR SPS PS)))
(COND ((AND (MEMBER ARG1
IS:STRUCTURE:LIST)
(NOT (MEMBER (LIST VECTOR SPS
PS)
IS:STRUCTURE:LIST)))
(SETQ PS (VECTOR I:DONT:KNOW:WHAT))
(SETQ SPS ARG1)
(SETQ ARG1
(COLON:BACK
(CDDR (COLON:BREAK ARG1))))
)
(T ARG1)))
(T (SETQQ PS ARG1)
(SETQQ SPS (EVAL ARG2))
ARG1))))
,OR A SIMILAR ELEMENT, SUCH AS (@ PS)
INTO THE DATA STRUCTURE (@ SPS)
??? PLEASE RESPOND YES OR NO; IF YOU SAY 'YES', THEN I
WILL PROBABLY HAVE TO ASK YOU SOME MORE QUESTIONS.)
AFFECTS
(VECTOR THE CONDITIONAL:INSERTION ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ CODING:WARNING:LIST
(CONS (TUPLE 10 VECTOR DELETE ALL MENTION OF
(CADR CHOICE)
FROM ALL CODE GENERATED)
CODING:WARNING:LIST))))
BOTH:RESULTS
(QUOTE ((VECTOR NOTHING IN COMMON)))
YES:RESULTS
(QUOTE
((PUPRIN1
"
NOW WE MUST KNOW 2 THINGS:
(1) WHAT WE INSERT
(2) UNDER WHAT CONDITION WE DO THE INSERTION
NOTES ABOUT (1): IF WE ARE INSERTING AN ALREADY EXISTING THING, THEN
JUST GIVEITS NAME; IF IT IS NEW, GIVE AN EXPRESSION INDICATING HOW WE
GET IT, PERHAPS IN TERMS OF ARG1.
")
(PUPRINT (TUPLE RECALL THAT HERE, ARG1 IS INSTANTIATED AS
(@ ARG1)))
(PUPRIN1
"
NOTES ABOUT (2): YOU MAY REFER TO THE RESULT OF (1) AS ")
(PUPRIN1 (SETQ RS (PACK (TUPLE RESULT: (SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(PUPRIN1
(CONCAT
". THIS WILL BE ESPECIALLY USEFUL IF (1) IS NOT SIMPLY
AN OLD NAME. ALSO, WE "
(COND ((MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)
"DO")
(T "DO NOT"))
" ASSUME THAT PART OF THE
CONDITION (2) IS THE FACT THAT "))
(PUPRINT RS)
(PUPRIN1
"
IS ALREADY IN THE LIST. THIS NEEDNT BE
RESTATED. TYPNG SIMPLY ']' WILL CAUSE ME TO ASSUME YOU WANT THE CON-
DITION: ")
(PUPRINT (LIST RS (QUOTE ISNT)
NIL))
(PUPRIN1 "
USER: (1) : ")
(SETQ RESULTANT (LIST:TRANSLATE (INVECTOR (PREAD))
T))
(PUPRIN1 "
USER: (2): ")
(SETQ CONDIT (COND ((LIST:TRANSLATE (INVECTOR (PREAD))
T))
(RS)))
(COND ((AND (MEMBER PS IS:STRUCTURE:LIST)
(NOT (MEMBER ARG1 IS:STRUCTURE:LIST)))
(COND ((NULL (GETP ARG1 BEING))
(SETQ BNAME PS)
(SETQ FNAME ARG1)
(SETQ CODE (GETP PS META:CODE))
(SATISFY (VECTOR IS BEING FNAME))))
(PUT ARG1 DATA:STRUCTURE
(COPY (SUBALLEVELS ARG1 PS (COPY (GETP PS
DATA:STRUCTURE)))))
(MAPC (MAPCAR (CDR (GETP PS META:CODE))
(QUOTE CADDR))
(FUNCTION
(LAMBDA (PROP)
(COND
((GETP PROP BEING)
(PUT PROP DATA:STRUCTURE
(APPEND (GETP PROP
DATA:STRUCTURE)
(LIST (QUOTE ALTERNATE)
ARG1 PS))))))))
(SETQ IS:STRUCTURE:LIST (CONS ARG1 IS:STRUCTURE:LIST))))
(COND ((EQUAL (CADR RESULTANT)
(QUOTE AND))
(SETQ RESULTANT (APPEND (VECTOR LIST:JOIN)
(CDDR RESULTANT)))))
(SETQ HTAL (CADR (MEMBER (QUOTE ACCESS)
(GETP ARG1 DATA:STRUCTURE))))
(SETQ TAL (COND ((LISTP HTAL)
(CDR HTAL))))
(SETQ RESULTANT (SUBPAIR (MAPCAR TAL (FUNCTION
(LAMBDA
(A)
(CAR (LAST A)))))
(MAPCAR TAL (FUNCTION (LAMBDA
(A2)
(CDADR A2))))
(COPY RESULTANT)
T))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA
(TOL)
(MATCH (VECTOR (CADR CHOICE)
TYPE OF
(VECTOR
CONDITIONAL:INSERTION)
IS FRAG1 USED IN
ANY2)
TOL))))
(SETQ OANY2 ANY2)
(SETQ SOME:INSERTIONS:LIST (CONS (CADR CHOICE)
SOME:INSERTIONS:LIST))
(SETQ
TYPE:OF:LIST
(CONS
(VECTOR
(CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(SETQ
CD
(VECTOR
PROGN
(VECTOR SETQ (@ RS)
(INVECTOR RESULTANT))
(INVECTOR
(COND
((AND (MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)
(NOT:YET:INITIALIZED (EVAL RESULTANT)))
(VECTOR
COND
(APPEND
(VECTOR (VECTOR MEMBER (@ RS)
(@ SPS)))
(MAPCAR (CDADR (MEMBER (QUOTE ACCESS)
(GETP (EVAL
RESULTANT)
DATA:STRUCTURE)
))
(FUNCTION
(LAMBDA
(ACC)
(VECTOR SETQ
(CAR (LAST ACC))
(CADR ACC))))))
(APPEND
(VECTOR T)
(MAPCONC
(CADR (OUTVECTOR
(MEMBER (QUOTE INITIALIZE)
(GETP (EVAL RESULTANT)
DATA:STRUCTURE))))
(FUNCTION
(LAMBDA
(INI)
(LIST (CAR INI)
(COMMENT THIS INITIALIZES
(CAR (LAST INI)))))))))
)
((MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)
(VECTOR COND (VECTOR (VECTOR MEMBER
(@ RS)
(@ SPS)))))))
(VECTOR
COND
(VECTOR
(COND ((OR (EQUAL PS (QUOTE ARG1))
(MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST))
(VECTOR AND (VECTOR NOT
(VECTOR MEMBER
(@ RS)
(@ SPS)))
(INVECTOR CONDIT)))
(T (INVECTOR CONDIT)))
(PROGN
(SETQ
TSUB
(SUBST
RS
(QUOTE X)
(CADDR
(CAR (OUTVECTOR
(CADR (MEMBER (QUOTE INSERT)
(GETP SPS
DATA:STRUCTURE)))))
)))
(COND
((EQUAL PS (QUOTE ARG1))
(VECTOR
(COND ((EQUAL (CAR SPS)
(QUOTE EVAL))
(QUOTE SET))
(T (QUOTE SETQ)))
(COND ((MATCH (TUPLE EVAL ANY3)
SPS)
ANY3)
(T SPS))
(VECTOR SETUNION (@ SPS)
(COND
((ATOM RESULTANT)
(VECTOR LIST (@ RESULTANT)))
((MEMBER (CADR (INVECTOR
RESULTANT))
(TUPLE MAPCAR MAPCONC
LIST TUPLE
VECTOR APPEND
CONS))
RS)
(T (LIST VECTOR (QUOTE LIST)
RS))))))
((AND ARG2
(EQUAL (EVAL ARG2)
(SETQ
TS2
(CADR (MEMBER (QUOTE
ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))))
)
(SUBST TS2 (CADDR (MEMBER (QUOTE ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))
TSUB))
(T TSUB))))
(VECTOR T (VECTOR SETQ (@ RS)
NIL)))))
AND IS USED IN (@ OANY2))
TYPE:OF:LIST))
(SETQ CDFLAT (FLATTEN CD))
(MAPC CODING:WARNING:LIST
(FUNCTION
(LAMBDA
(CW)
(COND
((AND (MATCH (TUPLE ANY1 VECTOR COMMENT ANY2 IN
ANY3 UNDEFINED; WILL BE GOTTEN
LATER; FRAG1)
CW)
(MEMBER ANY2 CDFLAT)
(OR (MEMBER ANY3 CDFLAT)
(MEMBER (PACK (LIST (QUOTE POSSIBLE:)
ANY3))
CDFLAT)
(MEMBER (COLON:BACK (CDR (COLON:BREAK
ANY3)))
CDFLAT)))
(SETQ CODING:WARNING:LIST
(CONS (COPY (SUBALLEVELS (CADR CHOICE)
ANY3
(COPY CW)))
CODING:WARNING:LIST)))))))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
CONDITIONAL:INSERTION))
FAST:COMPLEX .14)
(PUTPROPS CONSTRAIN BEING T
IDEN (((EQUAL (CAR LI)
CONSTRAIN)
(INVECTOR LI)))
IMPLICIT:ARGS NO
EXPLICIT:ARGS (STRUC)
EXPLICIT:ARGS:CHECK T
NLAMBDA (LEGAL ILLEGAL)
NON:EVAL:ARGS T
WHAT (TUPLE CONSTRAIN THE POSSIBLE VALUES OF (@ STRUC))
HOW (TUPLE IF NO OTHER KNOWLEDGE, ASK THE USER)
WHY (TUPLE OFTEN, CONSTRAINTS MEAN SIMPLIFICATIONS WHICH IN TURN MEAN FASTER, SIMPLER CODE)
MAIN:EFFECTS (((VECTOR IS CONSTRAINED (VECTOR ANY1))
(VECTOR CONSTRAIN (@ ANY1)))
((VECTOR IS CONSTRAINED ANY1)
(VECTOR CONSTRAIN (@ ANY1))))
META:CODE (PROGN
(PUPRIN1
"
YOU MUST GIVE ME A LIST OF ALL THE VALUES THAT COULD EVER OCCUR AS
NAMES ON THE LIST STRUCTURE ")
(PUPRINT STRUC)
(PUPRIN1 "IF THIS ISN'T MEANINGFUL, REPLY NIL.
USER: ")
(COND ((SETQ CL (PREAD))
(SETQ IS:CONSTRAINED:LIST
(CONS (PROGN (MAPC CL
(FUNCTION
(LAMBDA
(PN1)
(MAPC CL (FUNCTION
(LAMBDA
(PN2 BTYPE FNAME)
(SETQ BTYPE (COND ((EQUAL PN1 PN2)
MODIFY:STRUCTURE)
(T
MAJOR:MODIFY:STRUCTURE)))
(SETQ FNAME
(COLON:BACK (LIST PN1 PN2
MODIFY:STRUCTURE)))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (@ FNAME)
TYPE OF
(LIST VECTOR BTYPE)
IS UNKNOWN BUT IS
USED IN
(CADR CHOICE))
TYPE:OF:LIST))
(SETQ
UNDEFINED:SECTION:LIST
(SETUNION UNDEFINED:SECTION:LIST
(LIST (VECTOR (@ FNAME)
TYPE OF
(LIST VECTOR
BTYPE)))))
))))))
(LIST STRUC CL))
(CONS STRUC IS:CONSTRAINED:LIST))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS DATA:STRUCTURE:DELETIONS BEING T
IDEN (((MATCH (TUPLE DELETE FRAG1 INTO ANY1)
LI)
(VECTOR DATA:STRUCTURE:INSERTIONS (@ ANY1)
(CAR FRAG1))))
IMPLICIT:ARGS (RESPONSE NTAG SARG EVER:DID PRECISE:CALL OUTER:FN PLACEMENT NCODE
DLOC)
EXPLICIT:ARGS (SNAME ENAME SINSERT)
EXPLICIT:ARGS:CHECK (AND (OR ENAME (SETQ ENAME
(COND ((MATCH (STRUCTURE (LIST ATOMS OF
TYPE ANY1))
(GETP SNAME META:CODE))
ANY1)
(T (QUOTE ATOM)))))
(OR SINSERT (SETQ SINSERT (CADR (MEMBER (QUOTE DELETE)
(GETP SNAME
DATA:STRUCTURE)))))
)
WHAT (TUPLE LOCATE THE PLACES IN THE CODE WHERE AN DELETION INTO THE (@ SNAME)
DATA STRUCTURE SHOULD BE MADE, AND FIX UP THE CODE UNDER CONTROL OF
THE USER)
HOW (TUPLE LOOK FOR ASSIGNMENTS X ← Y, WHERE X IS A KNOWN TYPE OF ELEMENT OF
(@ SNAME)
;THEN ASK THE USER IF, JUST AFTER GETTING THIS NEW X, WE SHOULD DELETE
IT INTO (@ SNAME)
AND, IF SO, UNDER WHAT CONDITIONS)
WHY (TUPLE BECAUSE A DATA STRUCTURE HAVING NO DELETIONS IS A VERY STRANGE
CONSTRUCT; ALSO, THE MOST LIKELY PLACE TO DELETE IS JUST AFTER A NEW
POTENTIAL ELEMENT IS CREATED)
META:CODE (PROGN
(SETQ EVER:DID 0)
(COND
((AND
(NOT (FLOW:PRECEDED (VECTOR DELETE FROM (@ SNAME))))
(PUPRIN1
(CONCAT
"
I AM NOT SURE WHETHER OR NOT TO DELETE ELEMENT(S) FROM " SNAME ".
SHOULD WE EVER DO SUCH DELETIONS?
USER: "))
(MEMBER (PREAD)
(TUPLE Y YES MAYBE)))
(MAPCAR
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(SETQ SARG (CADR (MEMBER ENAME (TUPLE (DETERMINE:ARG:VALUE
(LIST VECTOR B))
ARG1
(DETERMINE:ARG2:VALUE
(LIST VECTOR B))
ARG2
(DETERMINE:ARG3:VALUE
(LIST VECTOR B))
ARG3))))
(COND
((PROGN (SETQ NTAG2 NIL)
(SETQ NTAG
(CAR (FIND:AND:TAG
(COND (SARG (TUPLE SET (@ SARG)
ANY1))
(T (TUPLE SETQ (@ ENAME)
ANY1)))
(GETP B META:CODE))))
NTAG2)
(PUPRINT (TUPLE I HAVE FOUND AND TAGGED THE ASSIGNMENTS TO)
)
(COND (SARG (PUPRINT (TUPLE (@ SARG)
,WHICH IS INSTANTIATED AS))))
(PUPRINT (TUPLE (@ ENAME)
,WHICH IS THE TYPE OF ELEMENT OF THE DATA
STRUCTURE (@ SNAME)
;SHOULD I DELETE A NEW LISP STATEMENT,
JUST AFTER THIS ASSIGNMENT, WHICH
CONDITIONALLY WILL DELETE THE NEW
(@ ENAME)
INTO
(@ SNAME)
? ALL THIS IS IN THE FUNCTION
(@ B)
.ANSWER YES, NO, OR UNSURE -- UNSURE MEANS
THAT WE SHOULD BE MORE SPECIFIC ABOUT THIS
ASSIGNMENT ....))
(COND
((EQUAL (SETQ RESPONSE (PREAD))
(QUOTE UNSURE))
(PUPRINT NTAG)
(PUPRIN1
"
THIS IS THE CODE AND THE PROPOSED PLACE OF THE CONDITIONAL DELETEION.
NOW YOU MUST ANSWER YES OR NO
USER: ")
(SETQ RESPONSE (PREAD))))
(COND
((EQUAL RESPONSE (QUOTE YES))
(SETQ EVER:DID (ADD1 EVER:DID))
(PUPRIN1
"
OK, TYPE IN THE CONDITION NOW.
IT SHOULD BE A PREDICATE, WHICH IS TRUE IF THE DELETEION IS TO BE MADE,
AND FALSE IF THE INSERTION IS NOT TO BE MADE.
USER: ")
(PUT
B META:CODE
(GETCODE
(SUBST (TUPLE COND
(TUPLE (OUTVECTOR
(TRANSLATE (INVECTOR
(PREAD))
T))
(SUBST (COND
(SARG)
(T (@ ENAME)))
(QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NTAG)
B -1)))))))))
(COND
((NOT (ZEROP EVER:DID))
(VECTOR WE PUT IN A TOTAL OF (@ EVER:DID)
CONDITIONAL DELETIONS OF (PLURAL ENAME)
INTO
(@ SNAME)))
(T
(PUPRIN1
(CONCAT
"
I STILL HAVEN'T LOCATED ANY DELETEIONS AT ALL INTO THE DATA STRUCTURE
" SNAME "; PLEASE TELL ME WHEN I SHOULD (CONDITIONALLY) DURING THE
COURSE OF THE PROGRAM, DELETE A NEW MEMBER INTO " SNAME "
USER: "))
(SETQ HDLO (PREAD))
(COND
((MEMBER HDLO (TUPLE NOWHERE NEVER NONE))
(VECTOR THERE APPARENTLY ARE NO KNOWN DELETIONS INTO THE
DATA STRUCTURE))
(T
(SETQ DLOC (LOCATION:TRANSLATE HDLO))
(SETQ PRECISE:CALL (CAR DLOC))
(SETQ OUTER:FN (CADR DLOC))
(SETQ PLACEMENT (CADDR DLOC))
(SETQ NCODE (COPY (GETP OUTER:FN META:CODE)))
(SETQ NCODE (SELECTQ PLACEMENT (AFTER (FIND:AND:TAG
PRECISE:CALL
NCODE))
(BEFORE (FIND:AND:PRETAG PRECISE:CALL
NCODE))
(ERROR!)))
(PUPRIN1 (CONCAT "
OK, WHAT EXACTLY DO I DELETE INTO " SNAME "?
USER: "))
(SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR (PREAD))
T)))
(PUPRIN1
(CONCAT
"
OK, NOW TELL ME WHE CONDITION IER WHICH I SHOULD DELETE IN
U IN
U" RESPONSE " IN
US" SNAME "ER: ***TA"))
(PUT
OUTER:FN META:CODE
(GETCODE
(SUBST (TUPLE COND
(TUPLE (OUTVECTOR (TRANSLATE
(INVECTOR (PREAD))
T))
(SUBST RESPONSE (QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NCODE)
OUTER:FN -1))
(SETQ EVER:DID (ADD1 EVER:DID))
(VECTOR WE FOUND NO PLACE TO PUT AN DELETEION, SO WE HAD TO
QUERY THE USER, WHICH LED TO PUTTING A CONDITIONAL
DELETION INTO THE FUNCTION (@ OUTER:FN))))))))
(SETQ SOME:DELETIONS:LIST (CONS SNAME SOME:DELETIONS:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
MAIN:EFFECTS (((VECTOR SOME DELETIONS FRAG1)
(APPEND (VECTOR DATA:STRUCTURE:DELETIONS)
FRAG1)))
FAST:COMPLEX .14)
(PUTPROPS DATA:STRUCTURE:INSERTIONS BEING T
IDEN (((MATCH (TUPLE INSERT FRAG1 INTO ANY1)
LI)
(VECTOR DATA:STRUCTURE:INSERTIONS (@ ANY1)
(CAR FRAG1))))
IMPLICIT:ARGS (RESPONSE NTAG SARG EVER:DID PRECISE:CALL OUTER:FN PLACEMENT NCODE
DLOC)
EXPLICIT:ARGS (SNAME ENAME SINSERT)
EXPLICIT:ARGS:CHECK (AND (OR ENAME (SETQ ENAME
(COND ((MATCH (STRUCTURE (LIST ATOMS OF
TYPE ANY1)
)
(GETP SNAME META:CODE))
ANY1)
(T (QUOTE ATOM)))))
(OR SINSERT (SETQ SINSERT (CADR (MEMBER (QUOTE INSERT)
(GETP SNAME
DATA:STRUCTURE)))))
)
WHAT (TUPLE LOCATE THE PLACES IN THE CODE WHERE AN INSERTION INTO THE
(@ SNAME)
DATA STRUCTURE SHOULD BE MADE, AND FIX UP THE CODE UNDER CONTROL OF
THE USER)
HOW (TUPLE LOOK FOR ASSIGNMENTS X ← Y, WHERE X IS A KNOWN TYPE OF ELEMENT OF
(@ SNAME)
;THEN ASK THE USER IF, JUST AFTER GETTING THIS NEW X, WE SHOULD INSERT
IT INTO (@ SNAME)
AND, IF SO, UNDER WHAT CONDITIONS)
WHY (TUPLE BECAUSE A DATA STRUCTURE HAVING NO INSERTIONS IS A VERY STRANGE
CONSTRUCT; ALSO, THE MOST LIKELY PLACE TO INSERT IS JUST AFTER A NEW
POTENTIAL ELEMENT IS CREATED)
META:CODE (PROGN
(SETQ EVER:DID 0)
(COND
((AND
(NOT (FLOW:PRECEDED (VECTOR INSERT INTO (@ SNAME))))
(PUPRIN1
(CONCAT
"
I AM NOT SURE WHETHER OR NOT TO INSERT ELEMENT(S) INTO " SNAME ".
SHOULD WE EVER DO SUCH INSERTIONS?
USER: "))
(MEMBER (PREAD)
(TUPLE Y YES MAYBE)))
(MAPCAR
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(SETQ SARG (CADR (MEMBER ENAME (TUPLE (DETERMINE:ARG:VALUE
(LIST VECTOR B))
ARG1
(DETERMINE:ARG2:VALUE
(LIST VECTOR B))
ARG2
(DETERMINE:ARG3:VALUE
(LIST VECTOR B))
ARG3))))
(COND
((PROGN (SETQ NTAG2 NIL)
(SETQ NTAG
(CAR (FIND:AND:TAG
(COND (SARG (TUPLE SET (@ SARG)
ANY1))
(T (TUPLE SETQ (@ ENAME)
ANY1)))
(GETP B META:CODE))))
NTAG2)
(PUPRINT (TUPLE I HAVE FOUND AND TAGGED THE ASSIGNMENTS
TO))
(COND (SARG (PUPRINT (TUPLE (@ SARG)
,WHICH IS INSTANTIATED AS))))
(PUPRINT (TUPLE (@ ENAME)
,WHICH IS THE TYPE OF ELEMENT OF THE DATA
STRUCTURE (@ SNAME)
;SHOULD I INSERT A NEW LISP STATEMENT,
JUST AFTER THIS ASSIGNMENT, WHICH
CONDITIONALLY WILL INSERT THE NEW
(@ ENAME)
INTO
(@ SNAME)
? ALL THIS IS IN THE FUNCTION
(@ B)
.ANSWER YES, NO, OR UNSURE -- UNSURE
MEANS THAT WE SHOULD BE MORE SPECIFIC
ABOUT THIS ASSIGNMENT ....))
(COND
((EQUAL (SETQ RESPONSE (PREAD))
(QUOTE UNSURE))
(PUPRINT NTAG)
(PUPRIN1
"
THIS IS THE CODE AND THE PROPOSED PLACE OF THE CONDITIONAL INSERTION.
NOW YOU MUST ANSWER YES OR NO
USER: ")
(SETQ RESPONSE (PREAD))))
(COND
((EQUAL RESPONSE (QUOTE YES))
(SETQ EVER:DID (ADD1 EVER:DID))
(PUPRIN1
"
OK, TYPE IN THE CONDITION NOW.
IT SHOULD BE A PREDICATE, WHICH IS TRUE IF THE INSERTION IS TO BE MADE,
AND FALSE IF THE INSERTION IS NOT TO BE MADE.
USER: ")
(PUT
B META:CODE
(GETCODE
(SUBST
(TUPLE COND
(TUPLE (OUTVECTOR (TRANSLATE
(INVECTOR (PREAD))
T))
(SUBST (COND (SARG)
(T (@ ENAME)))
(QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NTAG)
B -1)))))))))
(COND
((NOT (ZEROP EVER:DID))
(VECTOR WE PUT IN A TOTAL OF (@ EVER:DID)
CONDITIONAL INSERTIONS OF (PLURAL ENAME)
INTO
(@ SNAME)))
(T
(PUPRIN1
(CONCAT
"
I STILL HAVEN'T LOCATED ANY INSERTIONS AT ALL INTO THE DATA STRUCTURE
" SNAME "; PLEASE TELL ME WHEN I SHOULD (CONDITIONALLY) DURING THE
COURSE OF THE PROGRAM, INSERT A NEW MEMBER INTO " SNAME "
USER: "))
(SETQ HDLO (PREAD))
(COND
((MEMBER HDLO (TUPLE NOWHERE NEVER NONE))
(VECTOR THERE APPARENTLY ARE NO KNOWN INSERTIONS INTO THE
DATA STRUCTURE))
(T
(SETQ DLOC (LOCATION:TRANSLATE HDLO))
(SETQ PRECISE:CALL (CAR DLOC))
(SETQ OUTER:FN (CADR DLOC))
(SETQ PLACEMENT (CADDR DLOC))
(SETQ NCODE (COPY (GETP OUTER:FN META:CODE)))
(SETQ NCODE (SELECTQ PLACEMENT (AFTER (FIND:AND:TAG
PRECISE:CALL
NCODE))
(BEFORE (FIND:AND:PRETAG PRECISE:CALL
NCODE))
(ERROR!)))
(PUPRIN1 (CONCAT "
OK, WHAT EXACTLY DO I INSERT INTO " SNAME "?
USER: "))
(SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR (PREAD))
T)))
(PUPRIN1
(CONCAT
"
OK, NOW TELL ME WHAT THE CONDITION IS UNDER WHICH I SHOULD INSERT " RESPONSE " INTO " SNAME "?
USER: "))
(PUT
OUTER:FN META:CODE
(GETCODE
(SUBST (TUPLE COND
(TUPLE (OUTVECTOR
(TRANSLATE (INVECTOR (PREAD))
T))
(SUBST RESPONSE (QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NCODE)
OUTER:FN -1))
(SETQ EVER:DID (ADD1 EVER:DID))
(VECTOR WE FOUND NO PLACE TO PUT AN INSERTION, SO WE HAD
TO QUERY THE USER, WHICH LED TO PUTTING A
CONDITIONAL INSERTION INTO THE FUNCTION
(@ OUTER:FN))))))))
(SETQ SOME:INSERTIONS:LIST (CONS SNAME SOME:INSERTIONS:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
MAIN:EFFECTS (((VECTOR SOME INSERTIONS FRAG1)
(APPEND (VECTOR DATA:STRUCTURE:INSERTIONS)
FRAG1)))
FAST:COMPLEX .14)
(PUTPROPS DEFER:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1))))
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (MEMBER D UNDEFERRED:DECISION:LIST)
WHAT (TUPLE DEFER THE DECISION (@ D)
AS LONG AS POSSIBLE)
HOW (TUPLE DECIDE WHEN THE CONSEQUENCES OF DECISION (@ D)
WOULD NEXT AFFECT OUR WRITING THE PROGRAM CODE, AND THEN DEMONIZE THAT SITUATION)
WHY (TUPLE THE LONGER WE CAN DEFER ANY DECISION, INCLUDING (@ D)
,THE GREATER THE CHANCES THAT WE WILL HAVE GAINED ENOUGH NEW KNOWLEDGE OF THE
TASK THAT WHEN WE MUST FINALLY CONSIDER (@ D)
WE WILL KNOW ENOUGH TO ANSWER IT EASILY)
MAIN:EFFECTS (((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1))))
WHEN ((UNDEFERRED:DECISION:LIST 40
(VECTOR BECAUSE THERE EXIST UNDEFERRED DECISIONS, SO WE MUST
LOOK AFTER THEM IN SOME WAY BEFORE PROCEDING))
((MEMBER D UNDEFERRED:DECISION:LIST)
89
(VECTOR BECAUSE (@ D)
IS ONE OF THOSE UNDEFERRED DECISIONS)))
META:CODE (PROGN (SETQ UNDEFERRED:DECISION:LIST (PULLOUT D UNDEFERRED:DECISION:LIST))
(SETQ SITU (WHEN:NEXT (VECTOR PUP REINVESTIGATE (@ D))))
(COND ((EQUAL (CAR SITU)
VECTOR)
(SETQ SITU (CDR SITU))))
(COND ((EVAL SITU)
(RESOLVE:DECISION (VECTOR (@ D)
SINCE
(@ SITU))))
((EQUAL SITU (LIST FOREVER))
T)
(T (SETQ DEFERRED:DECISION:LIST (CONS (VECTOR (@ D)
UNTIL
(@ SITU))
DEFERRED:DECISION:LIST)))))
AFFECTS (QUOTE ((WHEN:NEXT CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T
IMPLICIT:ARGS (SITU)
FAST:COMPLEX .14)
(PUTPROPS ELEMENT BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A STRUCTURE WHICH IS A MEMBER OF A LARGER STRUCTURE)
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION (VECTOR WHAT IS AN ELEMENT)
AFFECTS
(VECTOR CODE INVOLVING ELEMENT)
ELEMENT))
COMPLEXITY:VECTOR (.3 .3 .3 .3 .1)
IDEN (((EQUAL (TUPLE ELEMENT)
LI)
(VECTOR ELEMENT)))
DATA:STRUCTURE T
FAST:COMPLEX .12)
(PUTPROPS ENCODE BEING T
IDEN (((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI)))
IMPLICIT:ARGS (FNAME FDESC F1 CODE FARGS YY ORIG:FUNC ARG:LIST ARG:COMMENTS PCOUNT FARGS1 FARGS2
TEMPFARGS CFLAT BNAME TNAME ARG1LIST ARG2LIST)
EXPLICIT:ARGS (FUNC)
EXPLICIT:ARGS:CHECK (PROGN
(SETQ ORIG:FUNC FUNC)
(AND
(OR
(AND (MATCH (VECTOR (VECTOR FRAG1)
NAME ANY1 FRAG2 ANY2)
FUNC)
(SETQ FDESC FRAG1)
(SETQ FNAME ANY1)
(SETQ BNAME ANY2)
(SETQ F1 (CADR FDESC)))
(COND ((ATOM FUNC)
NIL)
(T (SETQ FUNC (CADR FUNC))
NIL))
(AND
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA
(TT)
(COND
((EQUAL (CADR TT)
FUNC)
(SETQ F1 (SETQ FDESC
(CADDDR (CDDDR TT))))
(SETQ FNAME FUNC)
(SETQ
BNAME
(CAR (OUTVECTOR (CADDR (CDDR TT)))))
(SETQ TNAME (CAR (LAST TT)))
T)))))
(COND
((NULL F1)
(SETQ F1 FNAME)
(SETQ TYPE:OF:LIST (NCONC1 TYPE:OF:LIST (VECTOR (@ F1)
IS
(SUBPAIR
(GETP BNAME
EXPLICIT:ARGS)
(CDR FUNC)
(GETP BNAME
META:CODE)
T)))))
((MEMBER (VECTOR (@ FUNC)
TYPE OF (LIST VECTOR BNAME))
ENCODABLE:SECTION:LIST))
((MEMBER FUNC ENCODABLE:SECTION:LIST))
((GETP BNAME ENCODABLE)
(SETQ
TYPE:OF:LIST
(CONS (VECTOR (@ FNAME)
TYPE OF (@ BNAME)
IS
(SETQ
F1
(SETQ
FDESC
(INVECTOR
(INSTANTIATE (SUBPAIR
(GETP BNAME EXPLICIT:ARGS)
(FIRSTN (LENGTH (GETP BNAME
EXPLICIT:ARGS))
(TUPLE ARG1 ARG2 ARG3
ARG4))
(GETP BNAME META:CODE))))))
AND IS USED IN (@ TNAME))
TYPE:OF:LIST))
(PRIN1 (CONCAT "DEBUG F1 FDESC " F1 " " FDESC))
(SETQ F1 FDESC)
(SETQ ENCODABLE:SECTION:LIST (CONS FUNC ENCODABLE:SECTION:LIST))))))
(OR (SATISFY (VECTOR ENCODABLE SECTION ORIG:FUNC))
(SATISFY (VECTOR ENCODABLE SECTION FUNC)))))
WHAT (VECTOR ENCODE A FUNCTION NAMED (@ FNAME)
TO ACCOMPLISH (@ BNAME)
BY USING, AMONG OTHER FACTS, (@ FDESC))
HOW (VECTOR DEFINE (@ FNAME)
USING
(@ FDESC))
WHY (VECTOR (@ FNAME)
IS CURRENTLY UNDEFINED)
META:CODE (PROGN (MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (PC)
(COND ((MATCH (VECTOR (@ F1)
IS FRAG1)
PC)
(SETQ CODE FRAG1))))))
(COND
((NULL CODE)
(PUPRIN1 "
MOVE CURSOR TO ")
(PUPRINT FNAME)
(PUPRIN1 "
PUP IS NOW GOING TO ENCODE THE PIECE
")
(PUPRETTYPRINT (LIST (LIST (OUTVECTOR F1))))
(PUPRIN1 "
OF THE FUNCTION ")
(PUPRIN1 FNAME)
(PUPRIN1 " INTO LISP. FUNCTION NAMES WILL
BE QUERIED IN PREORDER, AS NEEDED.
")
(SETQ ARG:LIST (CDR (SASSOC FNAME TRUE:FN:CALL:LIST)))
(SETQ CODE (LIST (GETCODE (OUTVECTOR F1)
FNAME 1)))
(SETQ FARGS (INTERSECTION FARGS FARGS))
(COND ((GREATERP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (SETDIFFERENCE FARGS TRIVIAL:BEING:LIST))))
(COND ((GREATERP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (SETDIFFERENCE FARGS ARG:LIST))))
(COND ((LESSP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (APPEND FARGS (DUMMIES (DIFFERENCE (LENGTH ARG:LIST)
(LENGTH FARGS)))))))
(SETQ FARGS (FIRSTN (LENGTH ARG:LIST)
FARGS))
T)
(T (SETQ FARGS (APPEND (GETP (CAR FDESC)
EXPLICIT:ARGS)
(GETP (CAR FDESC)
IMPLICIT:ARGS)))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION UNDEFINED:SECTION:LIST
(SETDIFFERENCE (OUTNIL (FLATTEN CODE))
(APPEND WRITTEN:PROGRAMS:LIST PUP6FNS
PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST IS:BEING:LIST
SET:OF:BEING:PARTS PUP6VARS))))))
(SETQ FARGS1 (MAPCONC FARGS (FUNCTION (LAMBDA (FF)
(COND ((MATCH (TUPLE A R G FRAG1)
(UNPACK FF))
(LIST FF)))))))
(SETQ FARGS2 (SETDIFFERENCE FARGS FARGS1))
(SETQ FARGS1 (SORT (COPY FARGS1)))
(SETQ TEMPFARGS NIL)
(SETQ PCOUNT 0)
(MAPC FARGS (FUNCTION (LAMBDA NIL (SETQ PCOUNT (ADD1 PCOUNT))
(COND ((MATCH (TUPLE A R G (@ PCOUNT))
(UNPACK (CAR FARGS1)))
(SETQ TEMPFARGS (NCONC1 TEMPFARGS
(CAR FARGS1)))
(SETQ FARGS1 (CDR FARGS1)))
(T (SETQ TEMPFARGS (NCONC1 TEMPFARGS
(CAR FARGS2)))
(SETQ FARGS2 (CDR FARGS2)))))))
(SETQ FARGS TEMPFARGS)
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG2 FRAG1)
(MEMBER COMMENT (CDR (MEMBER COMMENT (MEMBER
COMMENT
(SETQ CFLAT (FLATTEN CODE))))
))))
(MEMBER (QUOTE ARG3)
CFLAT))
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS
(DETERMINE:ARG3:VALUE CHOICE))
CODE))))
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG2 FRAG1)
(MEMBER COMMENT (CDR (MEMBER COMMENT CFLAT)))))
(MEMBER (QUOTE ARG2)
CFLAT))
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS
(DETERMINE:ARG2:VALUE CHOICE))
CODE))))
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG1 FRAG1)
(MEMBER COMMENT CFLAT)))
(MEMBER (QUOTE ARG1)
CFLAT))
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS
(DETERMINE:ARG:VALUE CHOICE))
CODE))))
(COND ((AND ARG2 (SETQ ARG2LIST (DETERMINE:ALL:ARG2:VALUES CHOICE))
(CDR (SETQ ARG2LIST (SETINTERSECTION ARG2LIST ARG2LIST))))
(SETQ CODE
(CONS (COMMENT I SEE THAT WE MAY ACTUALLY CALL THE FUNCTION WITH ARG2
ANY OF THE FOLLOWING: (INVECTOR ARG2LIST))
CODE))))
(COND ((AND ARG1 (SETQ ARG1LIST (DETERMINE:ALL:ARG:VALUES CHOICE))
(SETQ ARG1LIST (SETINTERSECTION ARG1LIST ARG1LIST))
(CDR ARG1LIST))
(SETQ CODE
(CONS (COMMENT I SEE THAT WE MAY ACTUALLY CALL THE FUNCTION WITH ARG1
ANY OF THE FOLLOWING: (INVECTOR ARG1LIST))
CODE))))
(EVAL (LIST (QUOTE DEFINEQ)
(LIST FNAME (APPEND (LIST (COND ((GETP BNAME NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (COND (FARGS)
(T NIL)))
CODE))))
(PUPRIN1 (CONCAT "
DRAW A LINE FROM THE FUNCTION CALL " (SASSOC FNAME TRUE:FN:CALL:LIST)
" OF THE FUNCTION " FNAME
" TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
"))
(PUPRETTYPRINT (LIST FNAME))
(LIST (VECTOR WE DEFINE THE FUNCTION (@ FNAME)
AS:
(INVECTOR CODE))))
POST:REQUISITES ((VECTOR IS BEING FNAME))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS EXAMINE:STRUCTURE BEING T
EXPLICIT:ARGS (PAT L)
EXPLICIT:ARGS:CHECK (COND ((EQUAL (CAR (QUOTE DSMATCH))
(QUOTE NOBIND))
(SETQQ DSMATCH MATCH))
(T T))
WHAT (TUPLE EXAMINE A DATA STRUCTURE)
HOW (TUPLE PATTERN-MATCH USING (@ DSMATCH)
TO FIND ALL DESIRED ELEMENTS OF THE STRUCTURE, AND DISPLAY THEM TO THE USER)
WHY (TUPLE THE USER WANTS TO LOOK AT ALL ENTRIES (PACK (LIST DSMATCH (QUOTE ING)))
THE PATTERN (@ PAT)
, IN THE DATA STRUCTURE (@ L))
META:CODE (PUPRIN1 (CONCAT "
THOSE MATCHING ARE: " (MAPCONC (COND ((ATOM L)
(EVAL L))
(T L))
(FUNCTION (LAMBDA (E)
(COND (($ (TUPLE (@ DSMATCH)
PAT E))
(LIST (CDR E)))))))))
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
GENERALIZATIONS (TUPLE MATCH)
ENCODABLE T
FAST:COMPLEX .13)
(PUTPROPS EXTRACT:RELEVANT:SUBSET IDEN (((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE EXTRACT THE SMALL NUCLEUS OF RELEVANT INFO FROM (@ NEW:INFO))
HOW (TUPLE BY DELETING ALL THE IRRELEVANT INFO FROM (@ NEW:INFO))
WHY (TUPLE ONLY A SMALL AMOUNT OF INFO IS RELEVANT TO ANY SPECIFIC PROBLEM, AND PUP
CANNOT HANDLE A LARGE MASS OF INFO EFFICIENTLY)
WHEN (((GREATERP (SIZE NEW:INFO)
50)
70
(QUOTE (BECAUSE IF THE NEW INFO IS OVER 50 TOKENS LONG, THEN WE CANNOT
EFFICIENTLY COMPREHEND IT)))
((LESSP (SIZE NEW:INFO)
12)
-80
(QUOTE (BECAUSE IF THE NEW INFO IS LESS THAN A DOZEN TOKENS LONG THEN WE
SHOULD EASILY BE ABLE TO PROCESS IT AS IT IS))))
META:CODE (PROGN (USE:PROGRAMMING:KNOWLEDGE APPLIED TO NEW:INFO SO:AS:TO KEEP
(VECTOR RELEVANT NEW:INFO))
(SETQ RELEVANT:INFO:LIST (CONS NEW:INFO RELEVANT:INFO:LIST)))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO NEW:INFO:LIST)
MAIN:EFFECTS (((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1))))
AFFECTS (QUOTE ((APPLY:PROGRAMMING:KNOWLEDGE CALLED)))
COMPLEXITY:VECTOR (.3 .6 .6 .5 .1)
FAST:COMPLEX .147)
(PUTPROPS FAST:GET:NAME BEING T
IDEN (((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI))))
IMPLICIT:ARGS (TEMP1 NE EV:NEW:NAME TEMPINT TREAD)
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER TO (@ EXPRESSION))
WHEN ((T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
-90)
(T 50))
(QUOTE (BECAUSE MOST OBJECTS SHOULD HAVE NO MORE AND NO LESS THAN ONE NAME))))
META:CODE (COND
((OR (NUMBERP (CAR (LAST (COLON:BREAK EV:NEW:NAME))))
(AND (MATCH (VECTOR ANY2)
EXPRESSION)
(NUMBERP (CAR (LAST (COLON:BREAK (CADR EXPRESSION)))))))
(PUPRIN1
"
HMMMMM..... IT SEEMS I'VE SEEN THIS IDENTIFIER BEFORE. I WON'T NEED
YOUR INTERACTION AFLL. SORRY TO TROUBLE YOU.
IS TH")
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((ATOM (EVAL NEW:NAME))
(EVAL NEW:NAME))
(T (CADR (EVAL NEW:NAME))))
(CADR EXPRESSION))
(SETQ OLDNAME:TAG T)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))
(T
(COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
(TERPRI)
(PUPRIN1 (CONCAT "IS THIS THE SAME AS A " EXPRESSION
" WHICH WE'VE ALREADY SEEN AND NAMED?
USER: "))
(SETQ TEMP1 (MEMBER (PREAD)
(QUOTE (Y YES MAYBE))))))
(COND (TEMP1 (SETQ NE (INTERSECTION (SETQ
TEMPINT
(MAPCONC
TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF
(@ EXPRESSION)
FRAG1)
TOL)
(LIST ANY1)))))))
TEMPINT))))
(COND
((CDR NE)
(PUPRIN1
(CONCAT
NE " ARE SUCH NAMES. "
"
SINCE THERE IS MORE THAN ONE, PLEASE TYPE IN TO ME THE NAME, AGAIN,
OF ONE OF THE ABOVE" "
OR TYPE IN ] IF THE NAME YOU WANT ISALLY ONE OF THESE AFTER ALL.
USER: SINCE"))
(SETQ TEMP1 (PREAD)))
(NE (PUPRIN1 (CONCAT "SINCE " (CAR NE)
" IS THE ONLY NAME FOR " EXPRESSION
",
AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
YOU WANT. AM I RIGHT?
USER: "))
(SETQ TEMP1 (COND ((MEMBER (PREAD)
(QUOTE (Y YES)))
(CAR NE)))))
(T (PUPRIN1 (CONCAT
"I DON'T KNOW ANY NAMES FOR " EXPRESSION
", SO YOU'LL HAVE TO
TYPE A BRAND NEW NAME IN TO ME. "))
(TERPRI)
(SETQ TEMP1 NIL)))
(COND (TEMP1 (SETQ OLDNAME:TAG T)
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TEMP1))
(T (PUPRIN1 "USER: ")
(SETQ TREAD (PREAD))
(SETQ TREAD (COND (TREAD)
((COLON:BACK (OUTVECTOR (OUTNIL (FLATTEN EXPRESSION))
)))))
(COND ((NOT (OR (MEMBER TREAD PRIMITIVE:PROGRAMS:LIST)
(NUMBERP (CAR (LAST (COLON:BREAK TREAD))))))
(SETQ TREAD (PACK (TUPLE (@ TREAD)
:
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER))
)))))
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TREAD)
(SET TREAD TREAD)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))))
)
COMMENTS ((COND ((NOT (ATOM NEW:NAME))
(SETQ NEW:NAME (CADR NEW:NAME)))
(T T))
(SETQ EV:NEW:NAME (COND ((ATOM NEW:NAME)
NEW:NAME)
(T (EVAL NEW:NAME)))))
PRE:REQUISITES ((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR (@ EXPRESSION)))
(VECTOR AWARE USER (VECTOR PUP WANTS USER TO TYPE IN NAME FOR (@ EXPRESSION)))
)
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP AND USER ARE ABLE TO REFER TO (@ EXPRESSION)
AS
(@ NEW:NAME)
WHICH IS (EVAL NEW:NAME))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2))))
COMPLEXITY:VECTOR (.1 .3 .2 .5 .1)
FAST:COMPLEX .115)
(PUTPROPS FAST:SATISFY IDEN (((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T))))
IMPLICIT:ARGS (TEMP:LIST EV:G)
EXPLICIT:ARGS (G FORCE:SAT)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL (@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
META:CODE (COND
((AND (MEMBER EV:G (FIRSTN 90 (EVAL (SETQ TEMP:LIST
(COLON:BACK (COPY (LIST (CADR G)
(CADDR G)
(QUOTE LIST))))))
))
(NOT FORCE:SAT)))
(T
(PROG
(B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA (E1)
(COND ((MATCH (CAR E1)
G)
(SETQ B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(SETQ BECAUSE (VECTOR WE CALL THE SIMPLEST BEING WHICH CAN BRING ABOUT THE
EFFECT (@ G)))
(COND
(B:LIST
(RETURN
(PROG
(CB:LIST POS:B)
(SETQ CB:LIST (COPY (MAPCAR B:LIST (QUOTE CDR))))
(SETQ CB:LIST (INTERSECTION CB:LIST CB:LIST))
(SORT CB:LIST A:BEING:ORDER)
LABEL5
(SETQ POS:B (CAR CB:LIST))
(EVAL POS:B)
(COND
((MEMBER EV:G (EVAL TEMP:LIST))
(RETURN (SETQ PUP:SATISFIED:LIST (CONS G PUP:SATISFIED:LIST))))
((CDR CB:LIST)
(SETQ CB:LIST (CDR CB:LIST))
(GO LABEL5))
((MEMBER G USER:WARNING:LIST)
(RETURN NIL))
(T (PUPRIN1 "
WARNING: SATISFY IS SHAKING ITS HEAD ABOUT THIS ONE:")
(PUPRIN1 G)
(SETQ USER:WARNING:LIST (CONS G USER:WARNING:LIST))
(RETURN NIL))))))
(T (RETURN NIL))))))
COMMENTS ((SETQ G (EVAL G))
(SETQ EV:G (EVAL (CADDDR G))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1))))
AFFECTS (APPEND (MAPCAR (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION
(LAMBDA (E1)
(COND ((MATCH (CAR E1)
G)
(SETQ B:LIST (CONS (EVAL (CADR E1))
B:LIST)))))))
(RETURN B:LIST))
(FUNCTION (LAMBDA (Y)
(COND (Y (CONS Y (QUOTE (POSSIBLE:CALLED))))))))
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED))))
COMPLEXITY:VECTOR (0.0 .3 .2 .4 .1)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM ADAPT:PRECONCEIVED:FUNCTION)
BEING T
INHIBIT:CURRENT:DEMONS T
FAST:COMPLEX .114)
(PUTPROPS FILL:IN:UNDEFINED:SECTION BEING T
IDEN (((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI))))
IMPLICIT:ARGS (OLD:DO:LIST XTHING TC NEW:PIECE)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK UNDEFINED:SECTION:LIST
WHAT (VECTOR FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM
(@ PROGRAM))
HOW (VECTOR CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
WHY (VECTOR BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
WHEN ((UNDEFINED:SECTION:LIST 80
(TUPLE BECAUSE UNDEFINED:SECTION:LIST CONTAINS
PIECES OF CODE AS YET UNDEFINED))
((NULL UNDEFINED:SECTION:LIST)
-1000
(TUPLE BECAUSE NO PIECES OF CODE ARE KNOWN AND YET NOT YET DEFINED))
((SOME CODING:WARNING:LIST (FUNCTION (LAMBDA (COWL)
(LESSP (IMPROBABILITY:COMPLEX
COWL)
21))))
-150
(TUPLE BECAUSE A VERY EASY-TO-DO YET IMPORTANT FIXUP IS PENDING; IT IS
EASIER TO DO IT NOW THAN TO KEEP REMEMBERING IT AND DO IT LATER))
((SETINTERSECTION ENCODABLE:SECTION:LIST UNDEFINED:SECTION:LIST)
96
(TUPLE BECAUSE WE KNOW ENOUGH TO CODE EACH OF THE FOLLOWING SECTIONS:
(INVECTOR (SETINTERSECTION UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST)))))
META:CODE (COND ((SETQ NEW:PIECE (ENCODE CHOICE))
(SETQ UNDEFINED:SECTION:LIST (PULLOUT CHOICE
UNDEFINED:SECTION:LIST))
(COND ((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ UNDEFINED:SECTION:LIST (PULLOUT (LIST VECTOR ANY2)
UNDEFINED:SECTION:LIST))))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT CHOICE
ENCODABLE:SECTION:LIST))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SET PROGRAM (APPEND (EVAL PROGRAM)
NEW:PIECE)))
(T (SETQ DOING:PUP:LIST (CDDR DOING:PUP:LIST))
(SETQ PUP:WANTS:LIST (CONS (VECTOR MORE INFO RELEVANT TO
MAKING (@ CHOICE)
CODABLE)
PUP:WANTS:LIST))
NIL))
COMMENTS ((SETQ OLD:DO:LIST DOING:PUP:LIST)
(SETQ CHOICE (INVECTOR (MINIMUM (COND ((SETINTERSECTION
UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST))
(T UNDEFINED:SECTION:LIST))
FAST:BEING:COMPLEX)))
(SETQ DOING:PUP:LIST (CONS CHOICE DOING:PUP:LIST))
(SATISFY
(VECTOR
TYPE OF
(VECTOR
(SETQ
XTHING
(VECTOR
(PROG1 (COND ((ATOM CHOICE)
(SETQ TC CHOICE))
((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ TC ANY1)
ANY2)
(T (SETQ TC (CAR (OUTVECTOR CHOICE)))))
(SETQ DOING:PUP:LIST (CONS (INVECTOR (SASSOC TC
TRUE:FN:CALL:LIST))
DOING:PUP:LIST))
(MAPC (CDR (SASSOC TC TRUE:FN:CALL:LIST))
(FUNCTION
(LAMBDA (AA)
(COND
((ATOM AA)
(SATISFY
(VECTOR TYPE OF
(VECTOR (LIST VECTOR AA)
HAS BEEN STUDIED))
)))))))))
HAS BEEN STUDIED))
(AND (NOT (CAR (NLSETQ (SASSOC TC (OUTVECTOR OLD:DO:LIST)))))
(SOME TYPE:OF:LIST (FUNCTION
(LAMBDA (TOLL)
(AND (MATCH (VECTOR ANY1 TYPE OF (@ XTHING)
FRAG1)
TOLL)
(NOT (EQUAL ANY1 TC))))))
T)))
AFFECTS (QUOTE ((ENCODE CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS FIX:INCORRECT:PIECE BEING T
COMPLEXITY:VECTOR (.9 .9 .9 .9 .9)
WHEN ((T -10000 (COMMENT NOT IN YET)))
FAST:COMPLEX .9)
(PUTPROPS FOREACH BEING T
EXPLICIT:ARGS (X IN XSET DO ACTION)
EXPLICIT:ARGS:CHECK T
NLAMBDA T
NON:EVAL:ARGS T
WHAT (TUPLE GO THROUGH THE KNOWN SPACE OF (PLURAL X)
,WHICH IS (@ XSET)
,AND PERFORM (@ ACTION)
ON EACH, UNTIL SOME SPECIFIED TERMINATION CONDITION IS REACHED)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE LOOP REPEATEDLY)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR I ASSUME THAT I STOP AFTER EXAMINING ALL (PLURAL X)
IN
(@ XSET)
; DO I ALSO STOP AFTER SOME CONDITION 'C' BECOMES TRUE?)
COMMENT
(COMMENT THIS CONDITION 'C' SHOULD BE A PREDICATE, WHOSE SINGLE ARGUMENT IS
(@ X)
.'C' WORKS LIKE AN 'UNTIL' CLAUSE IN AN ITERATIVE STATEMENT. WE TEST
(PLURAL X)
UNTIL ONE OF THEM MAKES 'C' HAVE A NON-NULL VALUE. AT THAT TIME THE
FOREACH FUNCTION WILL RETURN A VALUE AND END.)
AFFECTS
(VECTOR THE FOREACH ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ DELTA:SECTION:1
(VECTOR COMMENT IF A CONDITIONAL TERMINATION IS LATER ADDED, IT
WILL PROBABLY REPLACE THIS COMMENT))
(SETQ DELTA:SECTION:2 (VECTOR GO (@ TEMPL)))))
BOTH:RESULTS
(QUOTE
((SETQ ARG:COMMENTS NIL)
(SETQ ARG:COUNTER 0)
(SETQ FCALL (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST))
(MAP2C (CDR FCALL)
(GETP FOREACH EXPLICIT:ARGS)
(FUNCTION (LAMBDA (FA1 FA2)
(SETQ ARG:COUNTER (ADD1 ARG:COUNTER))
(SET (PACK (TUPLE ARG (@ ARG:COUNTER)))
FA1)
(COND ((MEMBER FA1 TRIVIAL:BEING:LIST)
(SET FA2 FA1))
(T (SET FA2 (PACK (TUPLE ARG (@ ARG:COUNTER)))
)
(SETQ ARG:COMMENTS
(NCONC1 ARG:COMMENTS
(COMMENT IN ALL CALLS TO
DATE, (EVAL FA2)
IS BOUND TO
(INCOMMENT FA1))))))
)))
(SETQ
TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (VECTOR PROGN)
ARG:COMMENTS
(LIST (TUPLE PROG
(VECTOR (SETQ
TRESULT
(COLON:BACK
(TUPLE RESULT
(SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(VECTOR SETQ
(SETQ
EV:SET
(COLON:BACK
(LIST (QUOTE EVAL)
XSET)))
(VECTOR EVAL (@ XSET)))
(SETQ TEMPL
(COLON:BACK
(TUPLE LABEL (SETQ
LABEL:COUNTER
(ADD1 LABEL:COUNTER))))
)
(VECTOR COND
(VECTOR (VECTOR NULL
(@ EV:SET))
(VECTOR SET
(@ X)
FAILURE:VALUE)
(VECTOR RETURN
EXHAUSTION:VALUE)))
(VECTOR SET (@ X)
(VECTOR CAR (@ EV:SET)))
(VECTOR SETQ (@ EV:SET)
(VECTOR CDR (@ EV:SET)))
(VECTOR SETQ (@ TRESULT)
(VECTOR EVAL (@ ACTION)))
(EVAL DELTA:SECTION:1)
(EVAL DELTA:SECTION:2)))))
TYPE:OF:LIST))
(COND ((GETP XSET DATA:STRUCTURE))
(T (SETQ CODING:WARNING:LIST (CONS (TUPLE 95 VECTOR (EVAL XSET)
IS A DATA STRUCTURE, WITH
ELEMENTS OF TYPE
(EVAL X)
;BUT NO ACCESSION
INFORMATION IS KNOWN)
CODING:WARNING:LIST))))
(SETQ CODING:WARNING:LIST
(APPEND (LIST (TUPLE 45 VECTOR COMMENT WARNING FAILURE:VALUE IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL OR
A LITERAL SUCH AS FAIL FAILURE OR NOTHING SINCE
(VECTOR WHEN NO (@ ARG1)
IN
(@ ARG3)
SUFFICES, WE MUST BIND (@ ARG1)
TO SOME SPECIAL VALUE TO DISTINGUISH IT
FROM THE LAST 'SUCCESSFUL BINDING-- TO
THE LAST ELEMENT OF (@ ARG3)))
(TUPLE 45 VECTOR COMMENT WARNING EXHAUSTION:VALUE IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL
SINCE (VECTOR NO EXISTING (@ ARG1)
IN
(@ ARG3)
WILL SUFFICE. WE MUST KNOW WHAT
VALUE TO RETURN.))
(TUPLE 45 VECTOR COMMENT WARNING
(PACK (TUPLE INITIAL:VALUE:OF: (EVAL XSET)))
IN GLOBAL:CONTEXT:0 UNDEFINED; WILL BE GOTTEN
LATER; PROBABLY NIL OR THE INITIAL STATE OF
KNOWLEDGE ABOUT
(COLON:BACK (CDDR (COLON:BREAK (EVAL XSET))))
SINCE
(COMMENT AT THE BEGINNING WE ONLY KNOW A CONSTANT
AMOUNT OF INFORMATION, OFTEN NONE AT ALL)
))
CODING:WARNING:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
YES:RESULTS
(QUOTE
((SETQ TRESULT (COLON:BACK (TUPLE RESULT (ADD1 RESULT:COUNTER))))
(SETQ TEMPL (COLON:BACK (TUPLE LABEL (ADD1 LABEL:COUNTER))))
(SETQQ
DELTA:SECTION:1
(VECTOR
COND
(VECTOR
(SETQ
UC
(PROGN
(PUPRIN1
"
PLEASE TYPE IN A PREDICATE EQUIVALENT TO THIS UNTIL CONDITION 'C'.
USER: ")
(PUPRIN1 "(TYPING IN ] WILL MEAN THAT THE CONDITION IS THAT")
(PUPRINT TRESULT)
(PUPRIN1 " IS NONNULL.) USER: ")
(SETQ RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF ACTION)
TRESULT)
RESULT:BINDING:LIST))
(SETQ
RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF
(COND ((SOME ARG:COMMENTS
(FUNCTION
(LAMBDA
(ACM)
(MATCH (COMMENT
IN ALL CALLS TO
DATE, (@ ACTION)
IS BOUND TO
(COMMENT ANY2 FRAG1)
)
ACM))))
(SETQ
RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF
(@ ACTION))
TRESULT)
RESULT:BINDING:LIST))
ANY2)
(ACTION)))
TRESULT)
RESULT:BINDING:LIST))
(COND ((TRANSLATE (INVECTOR (PREAD))
T))
(T TRESULT))))
(VECTOR RETURN UNTIL:CONDITION:VALUE))
(VECTOR T (VECTOR GO (@ TEMPL)))))
(SETQQ DELTA:SECTION:2 (COMMENT AT THE TIME THAT (CADR CHOICE)
WAS CODED, THE UNTIL CONDITION VALUE WAS
LEFT UNDEFINED))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 45 VECTOR COMMENT WARNING UNTIL:CONDITION:VALUE IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY EITHER
(@ TRESULT)
NIL OR (COMMENT EVAL UNTIL:CONDITION)
OR
(COMMENT EVAL (@ X))
SINCE
(VECTOR THE UNTIL:CONDITION HAS BECOME TRUE FOR THE FIRST
TIME. WE MUST KNOW WHAT VALUE TO RETURN))
CODING:WARNING:LIST))))
FOREACH))
META:CODE (PROG (RESULTT)
(SETQ EVAL:ARG3 (EVAL XSET))
LABELL
(COND ((NULL EVAL:ARG3)
(SET X UNKNOWN)
(RETURN T)))
(SET X (CAR EVAL:ARG3))
(SETQ EVAL:ARG3 (CDR EVAL:ARG3))
(SETQ RESULTT (EVAL ACTION))
(GO LABELL))
IMPLICIT:ARGS (EVAL:ARG3)
FAST:COMPLEX .14)
(PUTPROPS GET:DATA:STRUCTURE BEING T
IDEN (((MATCH (TUPLE IS STRUCTURE ANY1)
LI)
(VECTOR GET:DATA:STRUCTURE ANY1 NIL))
((MATCH (TUPLE KEEPS TRACK OF FRAG1)
LI)
(PROGN (SETQ DSN (COLON:BACK (MAPCAR FRAG1 SINGULAR)))
(SETQ DSN1 (PACK (LIST DSN (QUOTE :SYSTEM))))
(SET DSN DSN)
(SET DSN1 DSN1)
(LIST VECTOR GET:DATA:STRUCTURE DSN1 DSN))))
IMPLICIT:ARGS (SCODE STYPE)
EXPLICIT:ARGS (SNAME ENAME)
EXPLICIT:ARGS:CHECK (AND SNAME (OR (NULL ENAME)
(LISTP (GETP ENAME DATA:STRUCTURE))
(AND (SATISFY (VECTOR IS STRUCTURE ENAME))
(PUT ENAME DATA:STRUCTURE
(APPEND (GETP ENAME DATA:STRUCTURE)
(TUPLE PARENT (@ SNAME)))))))
WHAT (TUPLE GET THE DETAILS OF INITIALIZATION, ACCESSION, INSERTION, AND DELETION FOR
THE CURRENTLY VAGUE DATA STRUCTURE (@ SNAME))
HOW (TUPLE SELECT AN INTERNAL REPRESENTATION FOR (@ SNAME)
AND, IF NECESSARY, FOR A TYPICAL ELEMENT (@ ENAME)
OF
(@ SNAME)
,AND THEN LET THAT REPRESENTATION DICTATE THE STRUCTURE ACCESSION ROUTINES)
WHY (TUPLE BECAUSE EVERY DATA STRUCTURE MUST HAVE SOME DEFINITE INTERNAL REPRESENTATION,
AND THE DETAILS OF THE REPRESENTATION IMPLY WHAT THE EFFICIENT ACCESS
ALGORITHMS MUST BE)
META:CODE (PROG1
(COND
((EQUAL T (GETP SNAME DATA:STRUCTURE))
(SETQ STYPE (SELECT:STRUCTURE:TYPE (SETQ SCODE (GETP SNAME META:CODE))))
(PUT SNAME DATA:STRUCTURE (EVAL (EVAL (PACK (LIST STYPE (QUOTE :SETUP)))))
))
((MEMBER SNAME ISNT:STRUCTURE:LIST))
(T
(PUPRIN1
"
PUP: SORRY TO BOTHER YOU, BUT I MUST KNOW IF THE FOLLOWING IS A
DATA STRUCTURE: ")
(PUPRIN1 SNAME)
(PUPRIN1 ". PLEASE ANSWER YES OR NO
USER: ")
(COND ((MEMBER (PREAD)
(VECTOR Y YES MAYBE))
(SETQ CODE (TUPLE STRUCTURE (TUPLE LIST ATOMS OF TYPE
(@ ENAME))))
(SETQ BNAME LIST:STRUCTURE)
(SETQ FNAME SNAME)
(SATISFY (VECTOR IS BEING FNAME))
(PUT SNAME DATA:STRUCTURE
(EVAL (EVAL (PACK (TUPLE (SELECT:STRUCTURE:TYPE
(SETQ SCODE (GETP SNAME META:CODE)
))
:SETUP))))))
(T (SETQ ISNT:STRUCTURE:LIST (CONS SNAME ISNT:STRUCTURE:LIST))))))
(COND ((GETP SNAME DATA:STRUCTURE)
(SETQ CODING:WARNING:LIST (NCONC1 CODING:WARNING:LIST
(TUPLE (COND (ENAME 100)
(266))
VECTOR WARNING WE HAVE FOUND
NO INSERTIONS INTO
(@ SNAME)
DATA STRUCTURE)))
(SETQ CODING:WARNING:LIST (NCONC1 CODING:WARNING:LIST
(TUPLE (COND (ENAME 101)
(267))
VECTOR WARNING WE HAVE FOUND
NO DELETIONS INTO
(@ SNAME)
DATA STRUCTURE)))
(SETQ IS:STRUCTURE:LIST (CONS SNAME (CONS (LIST VECTOR SNAME ENAME)
IS:STRUCTURE:LIST))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
MAIN:EFFECTS (((VECTOR IS STRUCTURE ANY1)
(COND ((MATCH (VECTOR ANY2 ANY3)
ANY1)
(LIST VECTOR GET:DATA:STRUCTURE ANY2 ANY3))
(T (VECTOR GET:DATA:STRUCTURE (@ ANY1)
NIL)))))
SPECIALIZATIONS (VECTOR
(VECTOR ONETYPE (VECTOR SET UP THE SKELEAL GET-DATA-STRUCTURE
STRUCTURE)
AFFECTS
(VECTOR THE GET:DATA:STRUCTURE ALGORITHM)
RESULTS
(QUOTE (PROGN (COND ((EQUAL (CAR (QUOTE ENAME))
(QUOTE NOBIND))
(SETQ SNAME (CADDR (INSIDE
GET:DATA:STRUCTURE
CHOICE)))
(SETQ ENAME (CADDDR (INSIDE
GET:DATA:STRUCTURE
CHOICE)))))
(SETQ BNAME LIST:STRUCTURE)
(SETQ FNAME ENAME)
(PUPRIN1
(CONCAT "
WHAT ARE THE PARTS OF A TYPICAL " ENAME " RECORD?
USER: "))
(SETQ EPARTS (PREAD))
(SETQ CODE
(CONS STRUCTURE
(MAPCAR EPARTS
(FUNCTION
(LAMBDA
(EP)
(TUPLE ATOMIC IDENTIFIER
(@ EP)))))))
(SET SNAME SNAME)
(SET ENAME ENAME)
(SETQ GLOBAL:INITIALIZATION:LIST
(APPEND GLOBAL:INITIALIZATION:LIST
(LIST (TUPLE SETQQ DSN
(@ DSN))
(TUPLE SETQQ DSN1
(@ DSN1)))))
(SATISFY (VECTOR IS BEING FNAME))
(SATISFY (VECTOR IS STRUCTURE (VECTOR SNAME
ENAME)))
(INVECTOR
(TUPLE PROGN (CADR (MEMBER (QUOTE INITIALIZE)
(GETP DSN1
DATA:STRUCTURE)))
(COMMENT OTHER INITIALIZATION MAY BE
DONE HERE)
(LIST REPEATEDLY (LIST TAKE:HOLD:OF
(SETQQ REQUEST
REQUEST))
(LIST MAJOR:MODIFY:STRUCTURE
REQUEST
(LIST (QUOTE QUOTE)
DSN1)))
(COMMENT FINALIZATION)))))
GET:DATA:STRUCTURE)
(VECTOR ADAPTATION (VECTOR DESIRED DIALOGUE BETWEEN (@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT DETAILS)
GET:DATA:STRUCTURE)
(VECTOR
ONETYPE
(COMMENT INSERT WARNINGS RELEVANT TO THE GETTING AND MAINTAINING OF
THE DATA STRUCTURE)
AFFECTS
(VECTOR DETAILS OF THE GET:DATA:STRUCTURE ALGORITHM)
RESULTS
(QUOTE
(PROGN
(SETQ BF (CAR (SOME IS:BEING:LIST (FUNCTION
(LAMBDA (B)
(MEMBER GET:DATA:STRUCTURE
(GETP B GENERALIZATIONS))))
)))
(MAPC
CODING:WARNING:LIST
(FUNCTION
(LAMBDA
(CW)
(COND
((AND (MATCH (TUPLE ANY1 VECTOR COMMENT WARNING ANY2 IN
ANY3 UNDEFINED; WILL BE GOTTEN
LATER; FRAG1)
CW)
(INSIDE ANY2 (GETP BF META:CODE))
(INSIDE ANY3 (GETP BF META:CODE)))
(SETQ
CODING:WARNING:LIST
(CONS
(PROGN
(PUPRIN1 "
WE ARE ADDING THE FOLLOWING WARNING: ")
(PUPRINT (COPY (SUBALLEVELS BF ANY3 (COPY CW)))))
CODING:WARNING:LIST)))))))))
FIXUP))
FAST:COMPLEX .14)
(PUTPROPS GET:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE GET (@ ENTITY)
INTO PUP'S AWARENESS)
HOW (TUPLE SEE IF (@ ENTITY)
IS ALREADY KNOWN; IF NOT, TRY TO COMPUTE IT; IF THIS ALSO FAILS, ASK THE USER ABOUT
IT)
WHY (TUPLE PUP NEEDS (@ ENTITY)
AT THIS POINT IN TIME)
META:CODE (OR (TAKE:HOLD:OF ENTITY)
(ASK:USER:ABOUT ENTITY))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
NLAMBDA T
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR DOES AN ALGORITHM ALREADY EXIST WHICH GETS
PRECISELY (@ ARG1))
AFFECTS
(VECTOR WHETHER WE CAN STOP THE GETTING ACTIVITY AND -- INSTEAD
-- WORK ON IMPLEMENTING)
WHEN
(VECTOR BEFORE ANY MORE ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE WE MAY NOT REALLY WANT A GETTING ROUTINE AFTER
ALL; WE MAY INSTEAD WANT AN IMPLEMENTING TYPE OF
ROUTINE.)
GET:HOLD:OF)
(VECTOR BOOLEAN (VECTOR DOES AN ALGORITHM EXIST WHICH GETS
(@ ARG1)
AND PERHAPS SOME OTHER STUFF)
AFFECTS
(VECTOR WHETHER WE CAN STOP TRYING TO 'GET' AND INSTEAD TRY TO
'IMPLEMENT')
WHEN
(VECTOR BEFORE ANY GET:HOLD:OF ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE TO DO SO EARLIER WOULD PRECLUDE THE CHANCE OF A
TRIVIAL SOLUTION TO THE GETTING; TO DO SO LATER MIGHT
CAUSE UNNECESSARY CODE TO BE WRITTEN)
GET:HOLD:OF)
(VECTOR BOOLEAN (VECTOR SHOULD WE IMPLEMENT ERROR RECOVERY IN ANY FANCY
WAY)
AFFECTS
(VECTOR STORAGE OF INTERMEDIATE RESULTS)
WHEN
(VECTOR AFTER ALL GET:HOLD:OF ROUTINES ARE FINALIZED)
NO:RESULTS
(QUOTE ((PUPRIN1 "
NOTHING TO DO AT THIS TIME, THEN.
")
NIL))
YES:RESULTS
(QUOTE ((PUPRIN1 " OOPS, NOT IN YET!! ")))
GET:HOLD:OF)
(VECTOR SOMEOF (VECTOR COMPUTE SEARCH GENERATE:AND:TEST)
COMMENT
(VECTOR THE SEARCH REFERS TO A KNOWN, FINITE SPACE; THE
GENERATE AND TEST REFERS TO AN UNKNOWN, INFINITE SET)
AFFECTS
(VECTOR THE GET:HOLD:OF ALGORITHM)
GET:HOLD:OF))
FAST:COMPLEX .14)
(PUTPROPS GET:NAME BEING T
IMPLICIT:ARGS (TEMP1 NE EV:NEW:NAME TEMPINT TREAD)
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
EXPLICIT:ARGS:CHECK T
IDEN (((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR FAST:GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR FAST:GET:NAME (CADR LI)
(CADDR LI))))
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER TO (@ EXPRESSION))
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR FAST:GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR FAST:GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR FAST:GET:NAME (@ ANY1)
(@ ANY2))))
WHEN ((T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
-90)
(T 50))
(QUOTE (BECAUSE MOST OBJECTS SHOULD HAVE NO MORE AND NO LESS THAN ONE NAME))))
META:CODE (PROGN
(PUPRIN1 (CONCAT "
PUP WANTS USER TO TYPE IN NAME FOR " EXPRESSION))
(COND
((OR (NUMBERP (CAR (LAST (COLON:BREAK EV:NEW:NAME))))
(AND (MATCH (VECTOR ANY2)
EXPRESSION)
(NUMBERP (CAR (LAST (COLON:BREAK (CADR EXPRESSION)))))))
(PUPRIN1
"
HMMMMM..... IT SEEMS I'VE SEEN THIS IDENTIFIER BEFORE. I WON'T NEED
YOUR INTERACTION AFLL. SORRY TO TROUBLE YOU.
IS TH")
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((ATOM (EVAL NEW:NAME))
(EVAL NEW:NAME))
(T (CADR (EVAL NEW:NAME))))
(CADR EXPRESSION))
(SETQ OLDNAME:TAG T)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))
(T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
(TERPRI)
(PUPRIN1 (CONCAT "IS THIS THE SAME AS A " EXPRESSION
" WHICH WE'VE ALREADY SEEN AND NAMED?
USER: "))
(SETQ TEMP1 (MEMBER (PREAD)
(QUOTE (Y YES MAYBE))))))
(COND (TEMP1 (SETQ NE (INTERSECTION (SETQ
TEMPINT
(MAPCONC TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND
((MATCH (VECTOR
ANY1 TYPE OF
(@ EXPRESSION)
FRAG1)
TOL)
(LIST ANY1)))))))
TEMPINT))))
(COND
((CDR NE)
(PUPRIN1 (CONCAT
NE " ARE SUCH NAMES. "
"
SINCE THERE IS MORE THAN ONE, TYPE IN THE NAME (AGAIN) " "
OF ONE OF THE ABOVE " "OR TYPE ] IF THE NAME YOU REALLY " "
WANT ISNT ONE OF THESE AFTER ALL " "
USER: "))
(SETQ TEMP1 (PREAD)))
(NE (PUPRIN1 (CONCAT "SINCE " (CAR NE)
" IS THE ONLY NAME FOR " EXPRESSION
",
AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
YOU WANT. AM I RIGHT?
USER: "))
(SETQ TEMP1 (COND ((MEMBER (PREAD)
(QUOTE (Y YES)))
(CAR NE)))))
(T (PUPRIN1 (CONCAT "I DON'T KNOW ANY NAMES FOR " EXPRESSION
", SO YOU'LL HAVE TO
TYPE A BRAND NEW NAME IN TO ME. "))
(TERPRI)
(SETQ TEMP1 NIL)))
(COND (TEMP1 (SETQ OLDNAME:TAG T)
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TEMP1))
(T (PUPRIN1 "USER: ")
(SETQ TREAD (PREAD))
(SETQ TREAD (COND (TREAD)
((COLON:BACK (OUTVECTOR (OUTNIL (FLATTEN EXPRESSION))))
)))
(COND ((NOT (OR (MEMBER TREAD PRIMITIVE:PROGRAMS:LIST)
(NUMBERP (CAR (LAST (COLON:BREAK TREAD))))))
(SETQ TREAD (PACK (TUPLE (@ TREAD)
:
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER))))
)))
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TREAD)
(SET TREAD TREAD)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST))))))
(PUPRIN1 "
THE NAME CHOSEN IS ")
(PUPRINT (EVAL NEW:NAME)))
COMMENTS ((COND ((NOT (ATOM NEW:NAME))
(SETQ NEW:NAME (CADR NEW:NAME)))
(T T))
(SETQ EV:NEW:NAME (COND ((ATOM NEW:NAME)
NEW:NAME)
(T (EVAL NEW:NAME)))))
COMPLEXITY:VECTOR (.1 .3 .2 .5 .1)
FAST:COMPLEX .115)
(PUTPROPS GET:NEW:INFORMATION IDEN (((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE GET THE NEW PIECE OF INFORMATION AND CALL IT (@ NEW:INFO))
HOW (TUPLE ASK THE USER FOR NEW INFORMATION)
WHY (TUPLE WE NEED NEW INFORMATION; SEE ESPECIALLY SPEC:WHY)
WHEN ((T (COND (NEW:INFO:LIST -68)
(T 50))
(QUOTE (BECAUSE WE SHOULD GET NEW INFORMATION IFF THERE IS NONE IN EXISTENCE)))
)
META:CODE (PROG1 (COND ((ATOM NEW:INFO)
(SET NEW:INFO (INVECTOR (PREAD))))
(T (SET (EVAL NEW:INFO)
(INVECTOR (PREAD)))))
(SETQ NEW:INFO:LIST (CONS (EVAL NEW:INFO)
NEW:INFO:LIST))
(SETQ PUP:WANTED:LIST (CONS (CAR PUP:WANTS:LIST)
PUP:WANTED:LIST))
(SETQ PUP:WANTS:LIST (CDR PUP:WANTS:LIST)))
COMMENTS ((PUPRIN1 "
USER: ")) PRE:REQUISITES ((VECTOR AWARE USER (APPEND (QUOTE (VECTOR PUP WANTS))
(CDAR PUP:WANTS:LIST))))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE SPECIFICITY:CHECK:DEMON)
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1))))
COMPLEXITY:VECTOR (.1 .1 .1 .5 .1)
FAST:COMPLEX .1)
(PUTPROPS GRAMMATICAL:INFERENCE BEING T
IDEN (((MEMBER LI (QUOTE ((GRAMMATICAL INFERENCE)
(GRAMMATICAL:INFERENCE)
(INFER GRAMMARS)
(INFERS GRAMMARS))))
(VECTOR GRAMMATICAL:INFERENCE)))
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE INFER FORMAL GRAMMAR RULES FROM EXAMPLARY STRINGS)
HOW (TUPLE BY BUILDING UP DESCRIPTIONS OF POSSIBLE RULES AND PRUNING)
WHY (TUPLE BECAUSE THIS IS THE ONLY EFFICIENT PARADIGM FOR GRAMMATICAL INFERENCE)
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR INFER GRAMMARS))
(VECTOR GRAMMATICAL:INFERENCE)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE INDUCTIVE:INFERENCE ENUMERATION PROBLEM:SOLVING)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(TUPLE PROGN
(VECTOR ABILITY TO INFER GRAMMARS DIFFERENTLY,
GIVEN THEIR TYPE)
(VECTOR ABILITY TO INFER GRAMMARS OF A GIVEN,
FIXED TYPE)
(TUPLE ERROR!))
COMMENT
(COMMENT THE FIRST ALTERNATIVE MEANS THAT THE GI
PROGRAM MUST QUERY THE USER AT THE START TO
DETERMINE THE CLASS OF GRAMMARS, THEN
PULLOUT THE RIGHT PROGRAM OR ELSE MODIFY ONE
ADAPTABLE PROGRAM. THE SECOND CHOICE IS THAT
THE GI PROGRAM CAN ALWAYS ASSUME A FIXED
CLASS OF GRAMMARS WILL BE INPUTTED)
AFFECTS
(VECTOR THE GRAMMATICAL:INFERENCE ALGORITHM)
RESULTS
(VECTOR (VECTOR INFER:MULTICLASS:GRAMMARS)
(VECTOR INFER:FIXEDCLASS:GRAMMARS))
GRAMMATICAL:INFERENCE)
(VECTOR ADAPTATION (VECTOR DESIRED DIALOGUE BETWEEN
(@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT DETAILS)
GRAMMATICAL:INFERENCE))
ALTERNATIVES (TUPLE CONCEPT:FORMATION EVOLUTION)
FAST:COMPLEX .14)
(PUTPROPS INFER:CONTEXTFREE:GRAMMARS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE INFER GRAMMARS OF TYPE TWO)
HOW (TUPLE BUILD UP THE CONSTRAINED RULES)
WHY (TUPLE THE CONSTRAINTS ON THE FORM OF THE REWRITING RULES ARE THAT THE LEFT
SIDE BE A SINGLE NONTERMINAL AND THE RIGHT SIDE BE NONNULL)
META:CODE (PROGN (SETQ SET:OF:RULES NIL)
(PARTITION:A:DOMAIN)
(TEST SET:OF:RULES))
COMMENTS ((PROG (BNAME CODE FNAME YY TARGS BARGS FARGS)
(SETQ BNAME ELEMENT)
(SETQ CODE (STRUCTURE (LEFT:SIDE ATOM L NONTERMINAL LETTER)
(RIGHT:SIDE SET R OF LETTERS)
(SET)))
(SETQQ FNAME RULE)
(SATISFY (VECTOR IS BEING FNAME))
(SETQQ PROBABLE:TESTS (PARSE TEST))
(PUT (QUOTE RULE)
LEFT:SIDE
(TUPLE CAR ARG1))))
AFFECTS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE GRAMMATICAL:INFERENCE)
ALTERNATIVES (TUPLE INFER OTHER CLASSES OF GRAMMARS)
ENCODABLE T
FAST:COMPLEX .14)
(PUTPROPS INFER:CONTEXTSENSITIVE:GRAMMARS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE INFER GRAMMARS OF TYPE ONE)
HOW (TUPLE BUILD UP THE CONSTRAINED RULES)
WHY (TUPLE THE CONSTRAINTS ON THE FORM OF THE REWRITING RULES ARE THAT THE
RIGHT SIDE BE AT LEAST AS LONG AS THE LEFT SIDE)
META:CODE (PROGN (SETQ SET:OF:RULES NIL)
(PARTITION:A:DOMAIN)
(TEST SET:OF:RULES))
COMMENTS ((PROG (BNAME CODE FNAME YY TARGS BARGS FARGS)
(SETQ BNAME ELEMENT)
(SETQ CODE (STRUCTURE (LEFT:SIDE SET L OF LETTERS)
(RIGHT:SIDE SET R OF LETTERS)
(SET)))
(SETQQ FNAME RULE)
(SATISFY (VECTOR IS BEING FNAME))
(SETQQ PROBABLE:TESTS (PARSE TEST))
(PUT (QUOTE RULE)
LEFT:SIDE
(TUPLE CAR ARG1))))
AFFECTS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE GRAMMATICAL:INFERENCE)
ALTERNATIVES (TUPLE INFER OTHER CLASSES OF GRAMMARS)
ENCODABLE T
FAST:COMPLEX .14)
(PUTPROPS INFER:FIXEDCLASS:GRAMMARS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SINCE THERE IS ONLY ONE FIXED TYPE OF GRAMMAR WHICH (@ TASK:NAME)
IS SUPPOSED TO INFER, WE NEEDN'T VARY THE TECHNIQUES ACCORDING TO THE
GRAMMAR BEING INFERRED, WE JUST USE ITS RULE-CONSTRAINTS AND INFER
THE GRAMMAR)
HOW (TUPLE EMBODY THE RULE CONSTRAINTS OF THIS ONE TYPE OF GRAMMAR INTO THE
PROGRAM WHICH MUST INFER THE GRAMMAR)
WHY (TUPLE BECAUSE THE MORE SPECIALIZED OUR TASK IS, THE MORE EFFICIENT -- IN
SIZE, COMPLEXITY, AND RUNNING TIME -- OUR (@ TASK:NAME)
PROGRAM CAN BE MADE EASILY)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE GRAMMATICAL:INFERENCE)
SPECIALIZATIONS (VECTOR (VECTOR ALTERNATIVES (VECTOR
INFER:PHRASESTRUCTURE:GRAMMARS
INFER:CONTEXTSENSITIVE:GRAMMARS
INFER:CONTEXTFREE:GRAMMARS
INFER:REGULAR:GRAMMARS)
AFFECTS
(VECTOR THE INFER:FIXEDCLASS:GRAMMARS ALGORITHM)
INFER:FIXEDCLASS:GRAMMARS))
ALTERNATIVES (TUPLE INFER:FIXEDCLASS:GRAMMARS)
FAST:COMPLEX .14)
(PUTPROPS INFER:MULTICLASS:GRAMMARS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE VARY THE TECHNIQUES ACCORDING TO THE GRAMMAR BEING INFERRED, AND
INFER THE GRAMMAR)
HOW (TUPLE ASCERTAIN THE GRAMMAR TYPE AND USE ITS SPECIAL CONSTRAINTS TO LIMIT
THE SEARCH FOR LEGAL RULES)
WHY (TUPLE BECAUSE THE BEST GENERAL PROGRAM IS A COLLECTION OF EXPERTS)
GENERALIZATIONS (TUPLE GRAMMATICAL:INFERENCE)
SPECIALIZATIONS (VECTOR (VECTOR SOMEOF (VECTOR INFER:PHRASESTRUCTURE:GRAMMARS
INFER:CONTEXTSENSITIVE:GRAMMARS
INFER:CONTEXTFREE:GRAMMARS
INFER:REGULAR:GRAMMARS)
AFFECTS
(VECTOR THE INFER:MULTICLASS:GRAMMARS ALGORITHM)
INFER:MULTICLASS:GRAMMARS))
ALTERNATIVES (TUPLE INFER:FIXEDCLASS:GRAMMARS)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS INFER:PHRASESTRUCTURE:GRAMMARS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE INFER GRAMMARS OF TYPE ZERO)
HOW (TUPLE BUILD UP UNCONSTRAINED RULES)
WHY (TUPLE THERE ARE NO CONSTRAINTS ON THE FORM OF THE REWRITING RULES)
META:CODE (PROGN (SETQ SET:OF:RULES NIL)
(PARTITION:A:DOMAIN))
AFFECTS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE GRAMMATICAL:INFERENCE)
ALTERNATIVES (TUPLE INFER OTHER CLASSES OF GRAMMARS)
ENCODABLE T
COMMENTS ((PROG (BNAME CODE FNAME YY TARGS BARGS FARGS)
(SETQ BNAME ELEMENT)
(SETQ CODE (STRUCTURE (LEFT:SIDE SET L OF LETTERS)
(RIGHT:SIDE SET R OF LETTERS)
(SET)))
(SETQQ FNAME RULE)
(SATISFY (VECTOR IS BEING FNAME))
(SETQQ PROBABLE:TESTS:LIST (PARSE TEST))
(PUT (QUOTE RULE)
LEFT:SIDE
(TUPLE CAR ARG1))
(PUT (QUOTE RULE)
RIGHT:SIDE
(TUPLE CADR ARG1))))
SPECIALIZATIONS T
FAST:COMPLEX .14)
(PUTPROPS INFER:REGULAR:GRAMMARS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE INFER GRAMMARS OF TYPE THREE)
HOW (TUPLE BUILD UP THE CONSTRAINED RULES)
WHY (TUPLE THE CONSTRAINTS ON THE FORM OF THE REWRITING RULES ARE THAT THE LEFT SIDE
BE UNITARY AND THE RIGHT SIDE BE A TERMINAL FOLLOWED BY A NONTERMINAL)
META:CODE (PROGN (SETQ SET:OF:RULES NIL)
(PARTITION:A:DOMAIN)
(TEST SET:OF:RULES))
COMMENTS ((PROG (BNAME CODE FNAME YY TARGS BARGS FARGS)
(SETQ BNAME ELEMENT)
(SETQ CODE (STRUCTURE (LEFT:SIDE ATOM L NONTERMINAL LETTER)
(RIGHT:SIDE DOUBLETON R1.R2 OF TERMINAL AND
THEN NONTERMINAL LETTERS)
(SET)))
(SETQQ FNAME RULE)
(SATISFY (VECTOR IS BEING FNAME))
(SETQQ PROBABLE:TESTS (PARSE TEST))
(PUT (QUOTE RULE)
LEFT:SIDE
(TUPLE CAR ARG1))))
AFFECTS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE GRAMMATICAL:INFERENCE)
ALTERNATIVES (TUPLE INFER OTHER CLASSES OF GRAMMARS)
ENCODABLE T
FAST:COMPLEX .14)
(PUTPROPS IS:OF:TYPE BEING T
EXPLICIT:ARGS (OBJECT SPECIAL:KNOWLEDGE)
EXPLICIT:ARGS:CHECK (MATCH (TUPLE COMMENT FRAG1)
SPECIAL:KNOWLEDGE)
WHAT (TUPLE SEE IF (@ OBJECT)
IS OF THE TYPE SPECIFIED. THE PARTICULAR TYPE IS DELINEATED BY THE SPECIAL KNOWLEDGE
(@ SPECIAL:KNOWLEDGE))
HOW (TUPLE USE (@ SPECIAL:KNOWLEDGE)
DETAILS TO SEE IF IT CONTAINS (@ OBJECT))
WHY (TUPLE WE MUST BE ABLE TO TEST AN OBJECT (@ OBJECT)
AND SEE IF IT BELONGS TO THE TYPE (@ SPECIAL:KNOWLEDGE))
META:CODE (PROGN (ASK:USER:ABOUT OBJECT))
COMPLEXITY:VECTOR (.35 .35 .35 .35 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION
(VECTOR HOW DO WE KNOW WHEN THE 'IS:OF:TYPE' PREDICATE IS TRUE,
AND WHEN IT IS FALSE? PUP ASSUMES THAT USER WILL TYPE IN
A LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT TO IT)
AFFECTS
(VECTOR CODE INVOLVING IS:OF:TYPE)
IS:OF:TYPE))
FAST:COMPLEX .125)
(PUTPROPS JOINING:FUNCTION BEING T
EXPLICIT:ARGS ALIST
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE JOIN TOGETHER THE SET (@ ALIST)
OF RESULTS)
HOW (TUPLE USE A JOINING TYPE OF SIMPLE FUNCTION)
WHY (TUPLE WE HAVE SEVERAL TEMPORARY RESULTS, AND WE MUST COMBINE THEM TO PRODUCE A SINGLE
RESULT)
META:CODE (COMMENT DEPENDS UPON THE SPECIFIC FLAVOR OF JOINING REQUIRED. USUSALLY AND, OR,
XOR, SERIES, ... ETC.)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE RELATING:FUNCTION FUNCTION)
SPECIALIZATIONS (VECTOR
(VECTOR
PREDICATE
(VECTOR WHEN WE TERMINATE THE LOOP)
AFFECTS
(VECTOR THE JOINING:FUNCTION ALGORITHM)
RESULTS
(OR
LOOP:TERMINATION:LIST
(AND
PROBABLE:TESTS:LIST
(PUPRIN1
"
IS THERE A TEST AT THE BEGINNING OF THIS JOINING FUNCTION?
USER: ")
(MEMBER (PREAD)
(TUPLE Y YES MAYBE))
(SETQQ SRESP
(APPEND (TUPLE COND)
(MAPCAR PROBABLE:TESTS:LIST
(FUNCTION (LAMBDA
(PR)
(LIST (APPEND (LIST IS:OF:TYPE)
A:LIST
(LIST COMMENT PT))
(CONS PT A:LIST)))))
(QUOTE (T (COMMENT THIS MAY NEVER BE NEEDED TO FILL
IN)))))
NIL)
(QUOTE LOOP:TERMINATION:LIST))
HOW
(INVECTOR (QUOTE (LAMBDA (PRED)
(COND ((MATCH (TUPLE DO UNTIL FRAG1)
PRED)
(QUOTE AND))
((OR (EQUAL (CAR PRED)
(QUOTE CDR))
(MATCH (TUPLE DO REPEATEDLY FRAG1)
PRED))
(QUOTE PROGN))
(T PRED)))))
JOINING:FUNCTION))
ALTERNATIVES (TUPLE SELECTING:FUNCTION ELIMINATING:FUNCTION)
PREDICATE T
FAST:COMPLEX .14)
(PUTPROPS LIST:STRUCTURE BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A LIST STRUCTURE ENTITY)
HOW (TUPLE A LIST OF ATOMS AND LIST STRUCTURES)
WHY (TUPLE ASSOCIATE THE PARTS OF THE LIST STRUCTURE)
META:CODE (STRUCTURE (CAR ATOM FRONT OF LIST:STRUCTURE)
(CDR LIST ALL BUT THE FRONT OF THE LIST:STRUCTURE))
COMPLEXITY:VECTOR (.2 .2 .2 .2 .1)
GENERALIZATIONS (TUPLE DATA:STRUCTURE)
DATA:STRUCTURE T
FAST:COMPLEX .11)
(PUTPROPS MAJOR:MODIFY:STRUCTURE BEING T
EXPLICIT:ARGS:CHECK T
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR SUBSETOF (VECTOR MODIFY:STRUCTURE MODIFY:UNTIL
MODIFY:SOME EXAMINE:STRUCTURE)
AFFECTS
(VECTOR THE MAJOR:MODIFY:STRUCTURE ALGORITHM)
MAJOR:MODIFY:STRUCTURE))
EXPLICIT:ARGS (ARG1)
FAST:COMPLEX .14)
(PUTPROPS MAKE:A:GUESS BEING T
IDEN (((MATCH (TUPLE YOUR GUESS)
LI)
(PROGN (SETQ HA1 ARG1)
(DETERMINE:ARG:VALUE (LIST VECTOR TCHOICE))
(SETQ TH (COND ((EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK ARG1)))
(VECTOR COMMENT MY GUESS FOR (VECTOR COMEVAL @ ARG1)
IS
(VECTOR COMEVAL EVAL ARG1)))
((EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK ARG2)))
(VECTOR COMMENT MY GUESS FOR (@ ARG2)
IS
(LIST VECTOR @ ARG2)))
(T (FLOOREM T)
(QUOTE POSSIBLE:NAME:OF:CLASS))))
(SETQ ARG1 HA1)
TH)))
EXPLICIT:ARGS (POSS:OBJ)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE FIGURE OUT WHAT OUR 'GUESS' REFERS TO, AND POINT TO IT)
HOW (TUPLE EXAMINE OBJECTS BEGINNING POSSIBLE...)
WHY (TUPLE BECAUSE THE USER MAY REFER TO OBJECTS BY THEIR FEATURES, NOT THEIR NAMES)
META:CODE (PROGN (PUPRIN1 " BY GUESS I ASSUME YOU ARE REFERRING TO ")
(PUPRIN1 POSS:OBJ))
SPECIALIZATIONS (VECTOR (VECTOR ONETYPE
(VECTOR WE FIGURE OUT A GUESS AND PROGRAM IT IN; NO DECISION
TO MAKKE)
AFFECTS
(VECTOR THE MAKE:A:DECISION ALGORITHM)
RESULTS
(OR POSS:OBJ (EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK (SETQ POSS:OBJ ARG1))))
(EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK (SETQ POSS:OBJ ARG2)))))
MAKE:A:GUESS))
FAST:COMPLEX 1.0)
(PUTPROPS MAKE:ENCODABLE BEING T
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR TRY TO MAKE (@ B:CALL)
ENCODABLE)
HOW (TUPLE FIRST SEE IF IT ALREADY IS; IF NOT, TRY TO USE DOMAIN:DEPENDENT KNOWLEDGE)
WHY (TUPLE BECAUSE (@ B:CALL)
MUST EVENTUALLY GET ENCODED)
MAIN:EFFECTS (((VECTOR ENCODABLE SECTION ANY1)
(VECTOR MAKE:ENCODABLE (@ ANY1))))
META:CODE (OR (AND (ATOM B:CALL)
(GETP B:CALL ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
TYPE OF (CAR (GETP B:CALL
GENERALIZATIONS))
IS
(INVECTOR (GETP B:CALL META:CODE)))
TYPE:OF:LIST)))
(AND (MATCH (VECTOR ANY1 TYPE OF ANY2 FRAG1)
B:CALL)
(SETQ ANY1:HOLD ANY1)
(SETQ ANY2:HOLD ANY2)
(COND ((MAKE:ENCODABLE ANY1))
((GETP ANY2:HOLD ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ ANY1:HOLD)
TYPE OF (@ ANY2:HOLD)
IS
(INVECTOR (GETP ANY2:HOLD
META:CODE)))))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
IMPLICIT:ARGS (ANY1:HOLD ANY2:HOLD)
FAST:COMPLEX .14)
(PUTPROPS MAKE:NEW:BEING BEING T
EXPLICIT:ARGS (FNAME)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR GIVE BIRTH TO THE NEW BEING (@ FNAME))
HOW (VECTOR FILL IN EACH PART OF A BEING, FOR THE BEING (@ FNAME))
WHY (VECTOR (@ FNAME)
MUST EXIST TO BE UNDERSTOOD)
MAIN:EFFECTS (((VECTOR IS BEING ANY1)
(VECTOR MAKE:NEW:BEING (@ ANY1))))
META:CODE (PROGN (SET FNAME FNAME)
(SETQ YY WRITE:PROGRAM)
(SETQ IS:BEING:LIST (CONS FNAME IS:BEING:LIST))
(SETQ TARGS (COND (FARGS (SETINTERSECTION FARGS FARGS))
((GETP BNAME EXPLICIT:ARGS))))
(SETQ BARGS (FIRSTN (LENGTH FARGS)
(GETP BNAME EXPLICIT:ARGS)))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (BP)
(COND ((GETP BNAME BP)
(PUT FNAME BP
(COND
(BARGS (SUBPAIR BARGS TARGS
(COPY (GETP BNAME BP))
T))
(T (GETP BNAME BP)))))))))
(PUT FNAME BEING T)
(PUT FNAME IDEN (SUBST FNAME BNAME
(MAPCAR (GETP FNAME IDEN)
(FUNCTION
(LAMBDA (ID)
(CONS (LIST Z@
(LIST Z@ (CAR ID)))
(CDR ID)))))))
(COND ((GETP BNAME ENCODABLE)
(PUT FNAME COMMENTS (MAPC (GETP BNAME COMMENTS)
(QUOTE EVAL)))))
(ADD:IDEN FNAME)
(PUT FNAME MAIN:EFFECTS (SUBST FNAME BNAME (COPY (GETP FNAME MAIN:EFFECTS)))
)
(ADD:EFFECTS FNAME)
(PUT FNAME EXPLICIT:ARGS TARGS)
(PUT FNAME WHAT (VECTOR A SPECIALIZED BEING WHICH DOES (GETP FNAME WHAT)))
(PUT FNAME WHY (APPEND (GETP FNAME WHY)
(TUPLE AND (@ BNAME)
IS TOO GENERAL TO USE AS IT IS)))
(PUT FNAME META:CODE (COND ((LESSP (LENGTH CODE)
2)
(CAR CODE))
((NOT (LISTP (CAR CODE)))
CODE)
(T (CONS (QUOTE PROGN)
CODE))))
(COND ((LISTP (GETP FNAME EXPLICIT:ARGS:CHECK))
(PUPRIN1 (CONCAT "
IS " (GETP FNAME EXPLICIT:ARGS:CHECK)
" STILL THE PROPER EXPLICIT
ARGS CHECK FOR THE FUNCTION " FNAME "? (I DON'T THINK IT IS!!)
USER: "))
(COND ((NOT (MEMBER (PREAD)
(TUPLE Y YES)))
(PUPRIN1 "
WHAT IS THE CHECK, THEN? (I SUGGEST 'T')
USER: ")
(PUT FNAME EXPLICIT:ARGS:CHECK (OUTVECTOR
(LIST:TRANSLATE (INVECTOR (PREAD))
T)))))))
(PUT FNAME GENERALIZATIONS (CONS BNAME (GETP FNAME GENERALIZATIONS)))
(PUT FNAME AFFECTS (PROG (X)
(SETQ X (VECTOR))
(MAPC (FLATTEN CODE)
(FUNCTION
(LAMBDA (CC)
(COND
((GETP (CAR (COLON:BREAK CC))
BEING)
(SETQ
X
(NCONC1 X
(VECTOR (@ CC)
POSSIBLE
CALLED)))
(SETQ YY (CONS CC YY)))))))
(RETURN X)))
(PUT FNAME SPECIALIZATIONS NIL)
(PUT FNAME COMPLEXITY:VECTOR (VECTOR:AVERAGE YY))
(SEMI:COMPILE FNAME)
T)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
IMPLICIT:ARGS (YY TARGS BARGS)
FAST:COMPLEX .14)
(PUTPROPS MESSAGE IDEN (((@ (AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2)))
(VECTOR MESSAGE (CADR LI)))
((@ (MATCH (TUPLE MAKE USER AWARE THAT FRAG1)
LI))
(VECTOR MESSAGE (INVECTOR FRAG1)))
((MATCH (TUPLE TELL ME FRAG1)
LI)
(VECTOR PUPRINT (VECTOR COMMENT I MUST TELL YOU (INVECTOR (INCOMMENT
(OUTVECTOR (TRANSLATE
(INVECTOR FRAG1)
T))))))))
BEING T
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL PREAD THE MESSAGE (@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE INFORMATION IN THE MESSAGE (@ M))
WHEN (((MEMBER M AWARE:USER:LIST)
-201
(QUOTE (BECAUSE THE USER NEVER FORGETS))))
META:CODE (PROGN (TERPRI)
(PUPRIN1 "PUP: ")
(PUPRINT (OUTVECTOR M))
(TERPRI)
(SETQ AWARE:USER:LIST (CONS M AWARE:USER:LIST))
(SETQ FRINGE:CONCIOUS:LIST (LIST M (CAR FRINGE:CONCIOUS:LIST)))
(SETQ LASTRESPONDER (QUOTE PUP))
(SETQ READ:USER:LIST (CONS M READ:USER:LIST)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR PREAD USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1))))
MINOR:EFFECTS ((QUOTE (LASTRESPONDER PUP)))
COMPLEXITY:VECTOR (0.0 .1 .9 .7 .1)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY)
FAST:COMPLEX .123)
(PUTPROPS METRICAL:CONCEPT:FORMATION BEING T
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION)
(METRIZE ORDER))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS MODIFY:SOME BEING T
EXPLICIT:ARGS (ARG1 ARG2)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE MODIFY ONLY CERTAIN SUB-STRUCTURES)
HOW (TUPLE GATHER UP THE STRUCTURES TO MODIFY AND DO IT)
WHY (TUPLE THIS IS LIKE APPLYING A FN TO ALL MEMBERS OF A SET SATISFYING A GIVEN PREDICATE)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR
(VECTOR
ONETYPE
(VECTOR WE GATHER UP ALL RELEVANT SUBSTRUCTURES AND THEN MODIFY THEM)
AFFECTS
(VECTOR THE MODIFY:SOME ALGORITHM)
RESULTS
(PROGN (SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (CAR (LAST CHOICE))
IS
(VECTOR MAPC MODIFY:SET
(INVECTOR (QUOTE (FUNCTION
(LAMBDA
(ILS)
(COND
((MODIFY:CONDITION
ILS)
(MODIFY:STRUCTURE
ARG1 ARG2))))))
))
AND IS USED IN (SETQ GU (GET:USAGE (CADR CHOICE)
MODIFY:SOME)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SETQ
CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR COMMENT WARNING MODIFY:CONDITION IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY SOME
PREDICATE, E.G, (CAR PROBABLE:TESTS:LIST)
OR
(CADR PROBABLE:TESTS:LIST)
SINCE
(COMMENT THESE TWO ARE THE MOST PROBABLE TESTS WHEN
(@ TASK)
IS INVOLVED))
(CONS (APPEND (TUPLE 150 VECTOR COMMENT WARNING MODIFY:SET
IN (CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER;
PROBABLY ONE OF)
(MAPCAR (SETDIFFERENCE
(CADR (SASSOC (QUOTE
SET:OF:POSSIBLE:NAMES:OF:CLASS)
IS:CONSTRAINED:LIST))
GU)
(FUNCTION
(LAMBDA
(G2)
(PACK (TUPLE SET:OF:
(CAR (COLON:BREAK
G2))
:STRINGS)))))
(TUPLE SINCE
(COMMENT THESE MAKE SENSE WITH RESPECT
TO THE MODIFY:CONDITION)))
CODING:WARNING:LIST))))
MODIFY:SOME))
FAST:COMPLEX .14)
(PUTPROPS MODIFY:STRUCTURE BEING T
EXPLICIT:ARGS (S ARG2)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE MODIFY THE STRUCTURE CONTAINING (@ S)
AS AN ELEMENT)
HOW (TUPLE BY SOME OF THESE: INSERTING, DELETING, ALTERING AN ELEMENT OR TWO)
WHY (TUPLE BECAUSE THE GIST OF CONCEPT FORMATION IS MODIFYING THE STRUCTURE WHICH
REPRESENTS A DESCRIPTION OF A CONCEPT)
META:CODE (VECTOR THIS DEPENDS ON WHAT THE USER WANTS DONE TO THE STRUCTURE)
COMPLEXITY:VECTOR (.7 .7 .7 .7 .5)
GENERALIZATIONS (TUPLE MODIFY)
SPECIALIZATIONS (VECTOR (VECTOR SUBSETOF (VECTOR CONDITIONAL:INSERTION
CONDITIONAL:DELETION COMPLEX:ALTERATION)
AFFECTS
(VECTOR THE MODIFY:STRUCTURE ALGORITHM)
COMMENT
(COMMENT CONDITIONAL:INSERTION MEANS WE WILL INSERT AN
ELEMENT LIKE THE ARG1 INTO THE SUITABLE OUTER
LIST STRUCTURE; CONDITIONAL:DELETION IS SIMILAR;
BOTH OF THESE ARE DONE ONLY WHEN SOME
YET-TO-BE-SPECIFIED CONDITION IS TRUE. THE FINAL
CHOICE, COMPLEX:MODIFICATION, MEANS THAT SOME
SUB-PARTS OF THE ARG1 ITSELF ARE TO BE INSERTED,
DELETED, OR CHANGED.)
MODIFY:STRUCTURE))
ALTERNATIVES (TUPLE REPLACE:STRUCTURE DELETE:ENTIRE:STRUCTURE)
FAST:COMPLEX .52)
(PUTPROPS MODIFY:UNTIL BEING T
EXPLICIT:ARGS (ARG1 ARG2)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE REPEATEDLY MODIFY UNTIL SOME CONDITION IS TRUE)
HOW (TUPLE BY ITERATION WITH A TEST AT EACH LOOPING CYCLE)
WHY (TUPLE THIS IS A STANDARD ITERATION LOOP)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR ONETYPE (VECTOR WE REPEATEDLY MODIFY STRUCTURE)
AFFECTS
(VECTOR THE MODIFY:UNTIL ALGORITHM)
RESULTS
(PROGN (SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (CAR (LAST CHOICE))
IS
(VECTOR REPEATEDLY
(VECTOR MODIFY:STRUCTURE
ARG1 ARG2))
AND IS USED IN (GET:USAGE
(CADR CHOICE)
MODIFY:UNTIL))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST)))
MODIFY:UNTIL))
FAST:COMPLEX .14)
(PUTPROPS OBTAIN:USABLE:INFORMATION IDEN (((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (U)
WHAT (TUPLE OBTAIN SOME INFORMATION WHICH CAN BE USED)
HOW (TUPLE OBTAIN NEW FACTS ABOUT OLD INFORMATION, OR OBTAIN TOTALLY NEW
INFORMATION)
WHY (TUPLE PUP HAS NO MORE INFORMATION THAT IT CAN USE TO PROGRESS)
WHEN ((T -10 (TUPLE SINCE THIS IS AN EXPONENTIALLY-GROWING, BAD THING TO DO IN
GENERAL))
(NEW:INFO:LIST 111
(QUOTE (BECAUSE WE SHOULD WORK ON UNASSIMILATED NEW
INFORMATION IF THERE IS ANY))))
META:CODE (PROGN (SETQ BECAUSE
(QUOTE (VECTOR WE CAN ONLY TRY TO OBTAIN USABLE
INFORMATION IN ONE WAY AT A TIME)))
(CHOOSE:FROM (QUOTE ((TRANSLATE U)
(GET:NEW:INFORMATION U)
(ANALYZE:IMPLICATIONS U)
(EXTRACT:RELEVANT:SUBSET U)))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1))))
AFFECTS (QUOTE ((CHOOSE:FROM CALLED)
(TRANSLATE POSSIBLE:CALLED)
(GET:NEW:INFORMATION POSSIBLE:CALLED)
(ANALYZE:IMPLICATIONS POSSIBLE:CALLED)
(EXTRACT:RELEVANT:SUBSET POSSIBLE:CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS OPTIMIZE BEING T
WHEN ((T -10000 (COMMENT NOT IN YET)))
COMPLEXITY:VECTOR (.9 .9 .9 .9 .9)
FAST:COMPLEX .9)
(PUTPROPS PARSE BEING T
EXPLICIT:ARGS (ARG1)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ATTEMPT TO PARSE THE STRING (@ ARG1)
FROM THE CURRENT SET OF RULES)
HOW (TUPLE APPLY THE CURRENT RULES IN REVERSE FORM)
WHY (TUPLE THIS IS A STANDARD, SIMPLE WAY TO PARSE)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE TEST)
SPECIALIZATIONS (VECTOR
(VECTOR BOOLEAN (COMMENT DO WE INITIALIZE AND MAINTAIN A PARSE TREE?)
AFFECTS
(VECTOR DETAILS OF THE PARSE ALGORITHM)
YES:RESULTS
(QUOTE (PROGN (SETQQ TREECOM (SETQ PARSE:TREE NIL))
(SETQ MAINTAIN:PARSE:TREE T)))
NO:RESULTS
(QUOTE (PROGN (SETQQ TREECOM (COMMENT NO PARSE TREE IS BEING KEPT))
(SETQ MAINTAIN:PARSE:TREE NIL)))
BOTH:RESULTS
(QUOTE (SOME (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND ((EQUAL (TUPLE PARSE TUPLE TEST)
(GETP B GENERALIZATIONS))
(SETQ BF B)
(PUT BF META:CODE
(SUBST TREECOM
(COMMENT HERE WE MIGHT
INITIALIZE THIS
PARSE'S TREE)
(COPY (GETP BF META:CODE))
))))))))
PARSE)
(VECTOR BOOLEAN
(COMMENT DO WE INITIALIZE AND MAINTAIN A LIST OF THE RULES USED DURING THE
PARSE?)
AFFECTS
(VECTOR DETAILS OF THE PARSE ALGORITHM)
YES:RESULTS
(QUOTE (PROGN (SETQQ RULECOM (SETQ RULES:USED NIL))
(SETQ MAINTAIN:RULES:USED T)))
NO:RESULTS
(QUOTE (PROGN (SETQQ RULECOM
(COMMENT NO RECORD OF THE RULES WHICH WERE USED IN THE
PARSE IS KEPT))
(SETQ MAINTAIN:RULES:USED NIL)))
BOTH:RESULTS
(QUOTE (SOME (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND ((EQUAL (TUPLE PARSE TUPLE TEST)
(GETP B GENERALIZATIONS))
(SETQ BF B)
(PUT BF META:CODE
(SUBST RULECOM
(COMMENT HERE WE MIGHT
INITIALIZE THIS
PARSE'S LIST OF
RULES USED)
(COPY (GETP BF META:CODE))
))))))))
PARSE)
(VECTOR
BOOLEAN
(COMMENT DO WE PARSE TO/FROM ALL LEGAL STRINGS, RATHER THAN SIMPLY FROM 'S')
AFFECTS
(VECTOR DETAILS OF THE PARSE ALGORITHM)
BOTH:RESULTS
(QUOTE (SOME (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA
(B)
(COND ((EQUAL (TUPLE PARSE TUPLE TEST)
(GETP B GENERALIZATIONS))
(SETQ BF B)
(SETQ CPOLD (INSIDE (QUOTE ENCLOSING)
(GETP BF META:CODE)))
(SETQ ANY1 (CAR (LAST CPOLD)))
(PUPRINT (COMMENT WE LOOK OVER THE NEW
(@ BF)
CODE))
(PUT BF META:CODE
(GETCODE (SUBST SCOM (QUOTE SLEGAL)
(SUBST (EVAL LOOPCOM)
CPOLD
(COPY (GETP BF
META:CODE))))
BF -1))))))))
YES:RESULTS
(QUOTE
(PROGN
(SOME (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND ((EQUAL (TUPLE PARSE TUPLE TEST)
(GETP B GENERALIZATIONS))
(SETQ BF B))))))
(SETQ
LOOPCOM
(TUPLE
TUPLE FOREACH S1 IN
(COND
((OR (AND (MEMBER (QUOTE SET:OF:LEGAL:STRINGS)
IS:DEFINED:LIST)
(GETP SET:OF:LEGAL:STRINGS DATA:STRUCTURE))
(AND (PUPRIN1 "
IS SET:OF:LEGAL:STRINGS PROBABLY GOING TO EXIST? ")
(MEMBER (PREAD)
(TUPLE Y YES MAYBE))
(SETQ IS:DEFINED:LIST (NCONC1 IS:DEFINED:LIST (SETQQ
SET:OF:LEGAL:STRINGS
SET:OF:LEGAL:STRINGS)))))
(QUOTE SET:OF:LEGAL:STRINGS))
(T (QUOTE (PROGN (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(TUPLE 101 VECTOR COMMENT WARNING
STRINGLIST IN (@ BF)
UNDEFINED; WILL BE GOTTEN LATER;
PROBABLY SOME SET:OF:STRINGS OF
KNOWN LEGALITY SINCE
(COMMENT WE SHOULD ONLY PARSE
TO/FROM LEGAL STRINGS TO
LEGAL STRINGS, OR ELSE
FROM ILLEGAL STRINGS TO
ILLEGAL STRINGS))))
(QUOTE STRINGLIST)))))
DO
(TUPLE @ ANY1)))
(SETQ CODING:WARNING:LIST (CONS (TUPLE 159 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG1 BY
(PACK (LIST BF (QUOTE :ARG1))))
CODING:WARNING:LIST))
(SETQQ SCOM S1)))
NO:RESULTS
(QUOTE (PROGN (SETQQ LOOPCOM ANY1)
(SETQQ SCOM (S))))
PARSE)
(VECTOR
BOOLEAN
(VECTOR DO WE PARSE BOTH FORWARDS AND BACKWARDS)
COMMENT
(COMMENT 'FORWARD' MEANS FROM LEGAL STRINGS TOWARD THE INPUT TARGET, 'BACKWARD'
MEANS FROM THE TARGET TOWARD SOME/ANY KNOWN LEGAL STRINGS USING
'ANTI-RULES')
AFFECTS
(VECTOR DETAILS OF THE PARSE ALGORITHM)
YES:RESULTS
(QUOTE
(SOME
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(COND
((EQUAL (TUPLE PARSE TUPLE TEST)
(GETP B GENERALIZATIONS))
(SETQ BF B)
(SETQ CODING:WARNING:LIST
(APPEND CODING:WARNING:LIST
(LIST (TUPLE 100 VECTOR COMMENT WARNING BPARSE:LEVEL IN
(@ BF)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY
ONE OF 2 3 4 5 SINCE
(COMMENT 1 IS TOO SHALLOW AND >5 IS TOO
LONG TO RUN REASONABLY))
(TUPLE 100 VECTOR COMMENT WARNING FPARSE:LEVEL IN
(@ BF)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY
ONE OF 2 3 4 5 SINCE
(COMMENT 1 IS TOO SHALLOW AND >5 IS TOO
DEEP AND WOULD TAKE TOO LONG)))))
(PUPRIN1
"
TYPE A DIGIT, AS FOLLOWS:
1 FORWARD. IF THIS FAILS, THEN TRY BACKWARD.
2 BACKWARD. IF THIS FAILS, THEN TRY FORWARD.
3 SIMULTANEOUSLY, TRY BOTH UNTIL ONE SUCCEEDS OR BOTH FAIL.
USER: ")
(SETQ PDISJUN (SELECTQ (PREAD)
(1 (QUOTE (OR (PARSE:FORWARD SLEGAL ARG1
FPARSE:LEVEL)
(PARSE:BACKWARD SLEGAL ARG1
BPARSE:LEVEL))))
(2 (QUOTE (OR (PARSE:BACKWARD SLEGAL ARG1
BPARSE:LEVEL)
(PARSE:FORWARD SLEGAL ARG1
FPARSE:LEVEL))))
(QUOTE (OR (PARSE:FORWARD SLEGAL ARG1 1)
(PARSE:BACKWARD SLEGAL ARG1 2)
(PARSE:FORWARD SLEGAL ARG1 3)
(PARSE:BACKWARD SLEGAL ARG1
BPARSE:LEVEL)
(PARSE:FORWARD SLEGAL ARG1
FPARSE:LEVEL))))))))))
)
NO:RESULTS
(QUOTE (SOME (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND ((EQUAL (TUPLE PARSE TUPLE TEST)
(GETP B GENERALIZATIONS))
(SETQ BF B)
(PUPRIN1 "
DO WE PARSE BACKWARDS?
USER: ")
(SETQ
PDISJUN
(COND
((MEMBER (PREAD)
(TUPLE Y YES))
(SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(TUPLE 100 VECTOR
COMMENT WARNING
BPARSE:LEVEL IN
(@ BF)
UNDEFINED; WILL
BE GOTTEN LATER;
PROBABLY 2 3 4 5
SINCE
(COMMENT ANY
SHALLOWER OR
DEEPER IS
VERY
RARE))))
(TUPLE PARSE:BACKWARD SLEGAL ARG1
BPARSE:LEVEL))
(T (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(TUPLE 100 VECTOR
COMMENT WARNING
FPARSE:LEVEL IN
(@ BF)
UNDEFINED; WILL
BE GOTTEN
LATER; PROBABLY
ONE OF 2 3 4 5
SINCE
(COMMENT THIS
IS THE
REASONABLE
RANGE OF
LEVELS OF
DEPTH))))
(TUPLE PARSE:FORWARD SLEGAL ARG1
FPARSE:LEVEL))))))))))
BOTH:RESULTS
(QUOTE (PROGN (PUPRINT (COMMENT WE LOOK OVER THE (@ BF)
CODE AGAIN.))
(PUT BF META:CODE (GETCODE (SUBST PDISJUN
(COMMENT SOME JOINED
FORWARD/BACKWARD PARSE
CALLS)
(COPY (GETP BF META:CODE)))
BF -1))))
PARSE)
(VECTOR ONETYPE (VECTOR HERE WE LAY THE SKELETON OF ANY PARSE ROUTINE)
AFFECTS
(VECTOR THE PARSE ALGORITHM)
RESULTS
(VECTOR PROGN ARG1
(COMMENT THIS APPEARANCE OF ARG1 IS JUST TO NUDGE PUP5 INTO NOTING
ITS INSTANTIATION HERE IN THE CODE)
(COMMENT HERE WE MIGHT INITIALIZE THIS PARSE'S TREE)
(COMMENT HERE WE MIGHT INITIALIZE THIS PARSE'S LIST OF RULES USED)
(VECTOR SETQ ARG1
(PROGN (SOME IS:BEING:LIST
(FUNCTION
(LAMBDA (B)
(AND (EQUAL (GETP B GENERALIZATIONS)
(LIST ELEMENT))
(SETQ
ELAC
(CADR (MEMBER (QUOTE ACCESS)
(GETP B
DATA:STRUCTURE)))))
)))
(SOME ELAC (FUNCTION (LAMBDA (EA)
(COND
((INSIDE
(QUOTE STRING)
EA)
(SETQ ACFN
(CAR EA)))))))
(INVECTOR (SUBST (QUOTE ARG1)
(QUOTE X)
(COPY ACFN)))))
(COMMENT PERHAPS A LOOP GOES HERE, ENCLOSING
(COMMENT SOME JOINED FORWARD/BACKWARD PARSE CALLS)))
PARSE))
PREDICATE T
IDEN (((EQUAL (CAR LI)
PARSE)
(INVECTOR LI))
((MATCH (TUPLE ANY1 CAN BE PARSED)
LI)
(LIST VECTOR PARSE ANY1)))
FAST:COMPLEX .14)
(PUTPROPS PARSE:BACKWARD BEING T
EXPLICIT:ARGS (ARG1 ARG2 ARG3)
EXPLICIT:ARGS:CHECK ARG1
WHAT (TUPLE PARSE BACKWARD FROM ARG2 TO ARG1)
HOW (TUPLE APPLY ANTIRULES TO ARG2 UNTIL THE RESULT IS ARG1)
WHY (TUPLE BECAUSE THIS IS THE TYPICAL BACKWARD PARSING -- BREADTH-FIRST SEARCHING --
ALGORITHM)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE PARSE)
SPECIALIZATIONS (VECTOR
(VECTOR BOOLEAN (VECTOR IS THERE A PARSE TREE TO MAINTAIN?)
AFFECTS
(VECTOR DETAILS OF THE PARSE:BACKWARD ALGORITHM)
HINT
(COND ((NLSETQ MAINTAIN:PARSE:TREE)
(COND (MAINTAIN:PARSE:TREE (QUOTE YES))
(T (QUOTE NO))))
(T NIL))
YES:RESULTS
(QUOTE (SETQQ BTREECOM (CONDITIONAL:INSERTION AR (QUOTE PARSE:TREE)
)))
NO:RESULTS
(QUOTE (SETQQ BTREECOM
(COMMENT THERE IS NO PARSE TREE MAINTENANCE TO DO)))
BOTH:RESULTS
(QUOTE (PROGN (PUPRINT (COMMENT WE ARE AGAIN LOOKING AT THE CODE
FOR (@ BF)))
(PUT BF META:CODE
(GETCODE (SUBST BTREECOM
(COMMENT PARSE TREE MAINTENANCE
MIGHT GO HERE)
(COPY (GETP BF META:CODE)))
BF -1))))
PARSE:BACKWARD)
(VECTOR BOOLEAN (VECTOR IS THERE A LIST OF RULES USED TO MAINTAIN?)
AFFECTS
(VECTOR DETAILS OF THE PARSE:BACKWARD ALGORITHM)
HINT
(COND ((NLSETQ MAINTAIN:RULES:USED)
(COND (MAINTAIN:RULES:USED (QUOTE YES))
(T (QUOTE NO))))
(T NIL))
YES:RESULTS
(QUOTE (SETQQ BRULESCOM (CONDITIONAL:INSERTION (ANTIRULE R)
(QUOTE RULES:USED)))
)
NO:RESULTS
(QUOTE (SETQQ BRULESCOM
(COMMENT THERE IS NO LIST OF RULES USED TO MAINTAIN
SO WE DON'T ACT HERE)))
BOTH:RESULTS
(QUOTE (PROGN (SETQ BF (CAR (SOME IS:BEING:LIST
(FUNCTION (LAMBDA
(B)
(MEMBER
PARSE:BACKWARD
(GETP B
GENERALIZATIONS)))))
))
(PUPRINT (COMMENT WE ARE AGAIN LOOKING AT THE CODE
FOR (@ BF)))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG1 BY
(PACK (LIST BF (QUOTE :ARG1))))
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG3 BY
(PACK (LIST BF (QUOTE :ARG3))))
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG2 BY
(PACK (LIST BF (QUOTE :ARG2))))
CODING:WARNING:LIST))
(PUT BF META:CODE
(GETCODE (SUBST BRULESCOM
(COMMENT RULES USED MAINTENANCE
MIGHT GO HERE)
(COPY (GETP BF META:CODE)))
BF -1))))
PARSE:BACKWARD)
(VECTOR
ONETYPE
(COMMENT THIS IS THE SKELETON FOR PARSING IN THIS DIRECTION)
AFFECTS
(VECTOR THE PARSE:BACKWARD ALGORITHM)
RESULTS
(QUOTE (INVECTOR
(QUOTE (COND ((EQUAL ARG1 ARG2)
T)
((ZEROP ARG3)
NIL)
(T (FOREACH R IN SET:OF:RULES DO
(FOREACH AR IN (APPLYRULE
(ANTIRULE R)
ARG2)
DO
(PROG1 (PARSE:BACKWARD
ARG1 AR
(SUB1 ARG3))
(COMMENT PARSE TREE
MAINTENANCE
MIGHT GO HERE)
(COMMENT RULES USED
MAINTENANCE
MIGHT GO HERE)
))))))))
PARSE:BACKWARD))
PREDICATE T
FAST:COMPLEX .14)
(PUTPROPS PARSE:FORWARD BEING T
EXPLICIT:ARGS (ARG1 ARG2 ARG3)
EXPLICIT:ARGS:CHECK ARG1
WHAT (TUPLE PARSE FORWARD FROM ARG1 TO ARG2)
HOW (TUPLE APPLY RULES TO ARG1 UNTIL THE RESULT IS ARG2)
WHY (TUPLE BECAUSE THIS IS THE TYPICAL FORWARD PARSING -- BREADTH-FIRST SEARCHING --
ALGORITHM)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE PARSE)
SPECIALIZATIONS (VECTOR
(VECTOR BOOLEAN (VECTOR IS THERE A PARSE TREE TO MAINTAIN?)
AFFECTS
(VECTOR DETAILS OF THE PARSE:FORWARD ALGORITHM)
HINT
(COND ((NLSETQ MAINTAIN:PARSE:TREE)
(COND (MAINTAIN:PARSE:TREE (QUOTE YES))
(T (QUOTE NO))))
(T NIL))
YES:RESULTS
(QUOTE (SETQQ FTREECOM (CONDITIONAL:INSERTION AR (QUOTE PARSE:TREE))
))
NO:RESULTS
(QUOTE (SETQQ FTREECOM
(COMMENT THERE IS NO PARSE TREE MAINTENANCE TO DO)))
BOTH:RESULTS
(QUOTE (PROGN (PUPRINT (COMMENT WE ARE AGAIN LOOKING AT THE CODE
FOR (@ BF)))
(PUT BF META:CODE
(GETCODE (SUBST FTREECOM
(COMMENT PARSE TREE MAINTENANCE
MIGHT GO HERE)
(COPY (GETP BF META:CODE)))
BF -1))))
PARSE:FORWARD)
(VECTOR BOOLEAN (VECTOR IS THERE A LIST OF RULES USED TO MAINTAIN?)
AFFECTS
(VECTOR DETAILS OF THE PARSE:FORWARD ALGORITHM)
HINT
(COND ((NLSETQ MAINTAIN:RULES:USED)
(COND (MAINTAIN:RULES:USED (QUOTE YES))
(T (QUOTE NO))))
(T NIL))
YES:RESULTS
(QUOTE (SETQQ FRULESCOM (CONDITIONAL:INSERTION R (QUOTE RULES:USED))
))
NO:RESULTS
(QUOTE (SETQQ FRULESCOM
(COMMENT THERE IS NO LIST OF RULES USED TO MAINTAIN
SO WE DON'T ACT HERE)))
BOTH:RESULTS
(QUOTE (PROGN (SETQ BF (CAR (SOME IS:BEING:LIST
(FUNCTION (LAMBDA
(B)
(MEMBER PARSE:FORWARD
(GETP B
GENERALIZATIONS)))))
))
(PUPRINT (COMMENT WE ARE AGAIN LOOKING AT THE CODE
FOR (@ BF)))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG1 BY
(PACK (LIST BF (QUOTE :ARG1))))
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG2 BY
(PACK (LIST BF (QUOTE :ARG2))))
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 100 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG3 BY
(PACK (LIST BF (QUOTE :ARG3))))
CODING:WARNING:LIST))
(PUT BF META:CODE
(GETCODE (SUBST FRULESCOM
(COMMENT RULES USED MAINTENANCE
MIGHT GO HERE)
(COPY (GETP BF META:CODE)))
BF -1))))
PARSE:FORWARD)
(VECTOR
ONETYPE
(COMMENT THIS IS THE SKELETON FOR PARSING IN THIS DIRECTION)
AFFECTS
(VECTOR THE PARSE:FORWARD ALGORITHM)
RESULTS
(QUOTE (INVECTOR
(QUOTE (COND ((EQUAL ARG1 ARG2)
T)
((ZEROP ARG3)
NIL)
(T (FOREACH R IN SET:OF:RULES DO
(FOREACH AR IN (APPLYRULE R ARG1)
DO
(PROG1 (PARSE:FORWARD
AR ARG2 (SUB1 ARG3))
(COMMENT PARSE TREE
MAINTENANCE
MIGHT GO HERE)
(COMMENT RULES USED
MAINTENANCE
MIGHT GO HERE))
)))))))
PARSE:FORWARD))
PREDICATE T
FAST:COMPLEX .14)
(PUTPROPS PARTITION:A:DOMAIN BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (COMMENT WE SHOULD NEVER REALLY BE HERE, SINCE THIS IS ALWAYS DONE BY A
COLLECTION OF THE THREE METHODS OF PARTITIONING DISCUSSED IN
THE 'SPECIALIZATIONS' SECTION)
(SETQ PARTITIONED:DOMAIN:LIST T))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY PARTIAL)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
ZERO CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY WEAK)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
MANY CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTION:A:DOMAIN)
(VECTOR SOMEOF (VECTOR PARTITION:BY:TAKE:ELE:AND:CLASS
PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:GET:CLASS)
AFFECTS
(VECTOR THE PARTITION:A:DOMAIN ALGORITHM)
PARTITION:A:DOMAIN))
IDEN (((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN)))
WHAT (TUPLE DIVIDE A DOMAIN INTO SUBDOMAINS; USUALLY THESE WILL BE DISJOINT, AND THEIR
UNION WILL BE THE ENTIRE DOMAIN)
HOW (TUPLE BY BUILDING UP THE PARTITION GRADUALLY, BY ADDING TO OUR KNOWLEDGE OF THE
PARTITION ONE PAIR AT A TIME; HERE A PAIR IS <ELEMENT, CLASS:NAME>)
WHY (TUPLE BECAUSE PUP MUST ENCODE A FUNCTION WHICH PARTITIONS A DOMAIN INTO CLASSES)
MAIN:EFFECTS (((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN)))
WHEN ((PARTITIONED:DOMAIN:LIST -100 (TUPLE BECAUSE WE ALREADY HAVE PARTITIONED DOMAIN))
((NULL PARTITIONED:DOMAIN:LIST)
20
(TUPLE BECAUSE PUP HAS NOT YET PARTITIONED DOMAIN, SO IT IS PLAUSIBLE TO DO IT
NOW)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON)
GENERALIZATIONS (TUPLE MAP BUILD:FUNCTION)
ALTERNATIVES (TUPLE DIVIDE:UP DISCRETIZE)
IMPLICIT:ARGS (PRESULT)
FAST:COMPLEX .14)
(PUTPROPS PARTITION:BY:TAKE:CLASS:GET:ELE BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (TAKE:HOLD:OF NAME:OF:CLASS)
(SETQ PRESULT (GET:HOLD:OF ELEMENT))
(TAKE:HOLD:OF ELEMENT)
(COMPLEX:MODIFY:STRUCTURE NAME:OF:CLASS ELEMENT PRESULT))
GENERALIZATIONS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
IMPLICIT:ARGS (PRESULT)
FAST:COMPLEX .14)
(PUTPROPS PARTITION:BY:TAKE:ELE:AND:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENTS AND THEIR
ASSOCIATED CLASS NAMES)
HOW (TUPLE PREAD IN PAIRS OF ELEMENT:CLASS)
WHY (TUPLE PARTITION IS DEFINED AS A SET OF ORDERED PAIRS)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(TAKE:HOLD:OF NAME:OF:CLASS)
(MODIFY:STRUCTURE NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
IMPLICIT:ARGS (PRESULT)
FAST:COMPLEX .14)
(PUTPROPS PARTITION:BY:TAKE:ELE:GET:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENT AND
DETERMINING THE CLASS IT BELONGS TO)
HOW (TUPLE PREAD IN ELEMENT, DEDUCE ITS CLASS)
WHY (TUPLE TO SHOW THAT THE PARTITIONING IS BEING DONE CORRECTLY)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(GET:HOLD:OF NAME:OF:CLASS)
(MODIFY:STRUCTURE NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
IMPLICIT:ARGS (PRESULT)
FAST:COMPLEX .14)
(PUTPROPS PATTERN:MATCH BEING T
IDEN (((MATCH (TUPLE MATCH ANY1 ANY2)
LI)
(LIST VECTOR PATTERN:MATCH ANY1 ANY2))
((MATCH (TUPLE MATCH ANY1)
LI)
(LIST VECTOR PATTERN:MATCH ANY1 (QUOTE LS)))
((MEMBER (QUOTE MATCHING)
LI)
(VECTOR (COND ((EQUAL (CAR (QUOTE DSMATCH))
(QUOTE NOBIND))
PATTERN:MATCH)
(T DSMATCH))
(CADR (MEMBER (QUOTE MATCHING)
(REVERSE LI)))
(COND ((LESSP (LENGTH (SETQ FR4 (CDR (MEMBER (QUOTE MATCHING)
LI))))
2)
FR4)
(T (TRANSLATE (INVECTOR FR4)
T)))))
((@ (@ (AND (MATCH (TUPLE FRAG1 MATCHES SOMETHING IN ANY1)
LI)
(NOT (MEMBER (QUOTE INSTEADOF)
FRAG1)))))
(VECTOR CAR (VECTOR SOME (LIST:TRANSLATE (INVECTOR ANY1)
T)
(VECTOR FUNCTION (VECTOR LAMBDA (VECTOR N)
(VECTOR (COND
((EQUAL (CAR (QUOTE DSMATCH))
(QUOTE NOBIND))
PATTERN:MATCH)
(T DSMATCH))
(LIST:TRANSLATE (INVECTOR FRAG1)
T)
N)))))))
EXPLICIT:ARGS (PAT EXP)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TRY TO MATCH THE PATTERN (@ PAT)
TO THE EXPRESSION (@ EXP))
HOW (TUPLE COMPARE CORRESPONDING SUBSTRUCTURES AND BIND VARIABLES IN THE PAT)
WHY (TUPLE WE WANT TO SEE IF THEY ARE COMPATIBLE, AND IF SO WHAT IN THE EXPRESSION
CORRESPONDS TO THE VARIABLES IN THE PATTERN)
META:CODE (MATCH PAT EXP)
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR
(VECTOR ONETYPE (COMMENT PATCH UP THE BODY OF THE MATCHING FUNCTION HERE)
AFFECTS
(VECTOR DETAILS OF THE PATTERN:MATCH ALGORITHM)
RESULTS
(QUOTE (PROGN (SETQ BF (CAR (SOME (SETDIFFERENCE IS:BEING:LIST
SET:OF:BEINGS)
(FUNCTION (LAMBDA
(B)
(MEMBER PATTERN:MATCH
(GETP B
GENERALIZATIONS)))))
))
(SETQ
CODING:WARNING:LIST
(CONS (TUPLE 151 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG1 BY
(PACK (LIST BF (QUOTE :ARG1))))
(CONS (TUPLE 151 VECTOR IN (@ BF)
WE SHOULD REPLACE ARG2 BY
(PACK (LIST BF (QUOTE :ARG2))))
CODING:WARNING:LIST)))))
FIXUP)
(VECTOR ONETYPE (COMMENT SET UP THE SKELETON OF THE MATCH)
AFFECTS
(VECTOR THE PATTERN:MATCH ALGORITHM)
RESULTS
(VECTOR PROGN (VECTOR ELIM:COMMON:HEAD ARG1 ARG2 (VECTOR QUOTE ARG1)
(VECTOR QUOTE ARG2))
(VECTOR ELIM:COMMON:TAIL ARG1 ARG2 (VECTOR QUOTE ARG1)
(VECTOR QUOTE ARG2))
(VECTOR COND
(VECTOR (VECTOR IS:OF:TYPE ARG1 ARG2
(COMMENT OK TO INCLUDE THIS COMBO
AS PLAUSIBLE NEW RULE))
(VECTOR LIST (VECTOR LIST ARG1 ARG2)
(VECTOR LIST ARG2 ARG1)))))
PATTERN:MATCH))
FAST:COMPLEX .13)
(PUTPROPS PROBABILITY=0:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
, WHICH MUST OCCUR WITH PROBABILITY = 0 (TUPLE I.E., NEVER)
CONTRADICTS THE PART OF THE WORLD SPECIFIED BY (@ WORLD))
HOW (TUPLE SINCE (@ OBJECT)
SHOULD NEVER OCCUR IN THE WORLD, IN PARTICULAR WE WILL HAVE A CONTRADICTION IF
IT OCCURS IN (@ WORLD)
;I.E., WE CHECK TO MAKE SURE THAT (@ OBJECT)
IS NOT A MEMBER OF (@ WORLD))
META:CODE (PROGN (COMMENT SINCE ARG1 SHOULD NEVER OCCUR, WE HAVE A CONTRADICTION IF IT IS A
MEMBER OF ARG2)
(MEMBER ARG1 ARG2))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T
FAST:COMPLEX .14)
(PUTPROPS PROBABILITY=1:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
,WHICH MUST OCCUR WITH PROBABILITY = 1, CONTRADICTS THE PART OF THE WORLD
SPECIFIED BY (@ WORLD))
HOW (TUPLE SINCE (@ OBJECT)
MUST OCCUR (TUPLE PROB. = 1)
WE SHALL CHECK TO SEE THAT (@ OBJECT)
IS A MEMBER OF (@ WORLD))
META:CODE (PROGN (COMMENT ARG1 OCCURS WITH PROBABILITY 1, SO IT HAD BETTER BE IN ARG2, THE
RELEVANT PIECE OF THE WORLD)
(NOT (MEMBER ARG1 ARG2)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T
FAST:COMPLEX .14)
(PUTPROPS PROBABILITY>0&<1:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF THE OBJECT (@ OBJECT)
CONTRADICTS
(@ WORLD)
%. SINCE THE FORMER HAS A PROBABILITY STRICTLY > 0, AND STRICTLY < 1, WE
CANNOT DO THIS EASILY)
HOW (TUPLE SINCE (@ OBJECT)
HAS A PROBABILITY STRICTLY BETWEEN 0 AND 1 OF OCCURRING IN (@ WORLD)
,THERE IS NO EASY WAY TO TEST FOR CONTRADICTION; THUS WE SIMPLY ALWAYS SAY
THAT THERE IS NONE.)
META:CODE (PROGN (COMMENT WE MAY OR MAY NOT HAVE ARG1 IN ARG2; EITHER CASE IS ALLOWABLE;
SO WE NEVER HAVE A CONTRADICTION)
NIL)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T
FAST:COMPLEX .14)
(PUTPROPS PROPOSE:PLAUSIBLE:NAMES BEING T
IDEN (((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI))))
IMPLICIT:ARGS (EXPRES2 NEW:EXPRES MSG)
EXPLICIT:ARGS (EXPRES)
EXPLICIT:ARGS:CHECK (COND ((ATOM EXPRES)
(SETQ NEW:EXPRES (COLON:BREAK EXPRES)))
(T (SETQ NEW:EXPRES
(PROG (TEMP1)
(MAPC EXPRES (FUNCTION
(LAMBDA (ZZ)
(SETQ TEMP1
(APPEND
TEMP1
(COLON:BREAK
ZZ))))))
(RETURN TEMP1)))))
WHAT (TUPLE PROPOSE PLAUSIBLE NAMES FOR (@ EXPRES))
HOW (TUPLE USE PARLOR PSYCHOLOGY TO EXTRACT MNEMONIC CONTRACTIONS OF (@ EXPRES))
WHY (TUPLE AID THE USER OR PUP IN CHOOSING A EXPRES FOR THE OBJECT (@ EXPRES))
MAIN:EFFECTS (((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1))))
WHEN ((T (COND ((MEMBER (TUPLE PLAUSIBLE NAMES FOR (@ EXPRES))
PUP:STUDIED:LIST)
-99)
(T 33))
(QUOTE (BECAUSE WE SHOULDNT WASTE OUTQUOTE NEW:EXPRES))))
META:CODE (PROG (P)
(SETQ EXPRES2 (OUTVECTOR (OUTQUOTE NEW:EXPRES)))
(SETQ P (MAPCAR (LIST (INITIALS EXPRES2)
(MAIN:WORDS EXPRES2)
(FIRST:FEW (INITIALS EXPRES2))
(FIRST:FEW (INITIALS (MAIN:WORDS EXPRES2)))
(LIST (PACK (INITIALS EXPRES2)))
(LIST (PACK (FIRST:FEW (INITIALS EXPRES2)))))
(QUOTE COLON:BACK)))
(SETQ P (SETDIFFERENCE P KNOWN:NAMES))
(SETQ P (INTERSECTION P P))
(SETQ MSG (VECTOR (@ P)
IS THE SET OF PLAUSIBLE NAMES OF (@ EXPRES2)
WHICH IS AN EXPANSION OF (@ EXPRES)))
(SETQ PLAUSIBLE:NAMES:LIST (CONS (VECTOR FOR (@ EXPRES)
HAVE BEEN STUDIED)
PLAUSIBLE:NAMES:LIST))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR PLAUSIBLE NAMES FOR
(@ EXPRES))
PUP:STUDIED:LIST))
(RETURN P))
POST:REQUISITES ((VECTOR AWARE USER (INVECTOR MSG)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON)
COMPLEXITY:VECTOR (.1 .2 .3 .5 .1)
FAST:COMPLEX .112)
(PUTPROPS RECOGNIZE:# BEING T
IDEN (((@ (MATCH (TUPLE ANY ANY1 IN ANY2 IS FRAG1)
LI))
(VECTOR DO UNTIL (VECTOR FORSOME (@ ANY1)
IN
(@ ANY2)
(TRANSLATE (APPEND (LIST VECTOR ANY1 IS)
FRAG1)
T))))
((@ (MATCH (TUPLE ANY1 IS INCOMPATIBLE WITH ANY2)
LI))
(VECTOR RECOGNIZE:# (@ ANY1)
(@ ANY2))))
PREDICATE T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
IS IN CONTRADICTION TO THE COLLECTION (@ WORLD))
HOW (TUPLE SEE HOW A (@ OBJECT)
TYPE OF OBJECT CAN BE CONTRADICTORY, THEN EXAMINE THE RELATIONSHIP BETWEEN
(@ OBJECT)
AND
(@ WORLD))
META:CODE (PROGN (DETERMINE:CONTRADICTION:CRITERIA)
(CHECK CONTRADICTION:CRITERIA OBJECT WORLD))
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
SPECIALIZATIONS (VECTOR (VECTOR SOMEOF (VECTOR PROBABILITY=1:# PROBABILITY=0:#
PROBABILITY>0&<1:#)
AFFECTS
(VECTOR THE RECOGNIZE:# ALGORITHM)
COMMENT
(COMMENT
THE FOLLOWING ARE THE 'HOW' PARTS OF THE ABOVE CHOICES:
(QUOTE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(MAPCAR (CDAR (CDDADR D))
(FUNCTION
(LAMBDA
(CHOI)
(MAP2C (TUPLE ARG1 ARG2 ARG3 ARG4
ARG5 ARG6)
(GETP CHOI EXPLICIT:ARGS)
(FUNCTION
(LAMBDA
(ARGK ARGU)
(SET ARGU (EVAL ARGK)))))
(LIST CHOI (EVAL (GETP CHOI HOW)))))
))))
RECOGNIZE:#))
FAST:COMPLEX .13)
(PUTPROPS RECOGNIZE:ARGS BEING T
IDEN (((Z@ (AND (MATCH (TUPLE A R G ANY1)
(UNPACK (CAR LI)))
(EQUAL LI (LIST (PACK (TUPLE A R G (@ ANY1)))))))
(CONS VECTOR LI)))
EXPLICIT:ARGS:CHECK T
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS RECOGNIZE:CAR BEING T
IDEN (((MATCH (TUPLE THE FRONT PART OF ANY1 FRAG1)
LI)
(APPEND (VECTOR CAR)
(COND ((ATOM (SETQ TTR (TRANSLATE (LIST VECTOR ANY1)
T)))
(LIST TTR))
(T (CDR TTR)))
(COND (FRAG1 (CDR (TRANSLATE (INVECTOR FRAG1)
T))))))
((MATCH (TUPLE THE FIRST ELEMENT OF FRAG1)
LI)
(VECTOR CAR (COND ((CDR FRAG1)
(LIST:TRANSLATE (INVECTOR FRAG1)
T))
(T (CAR FRAG1)))))
((MATCH (TUPLE THE SECOND ELEMENT OF FRAG1)
LI)
(VECTOR CADR (COND ((CDR FRAG1)
(LIST:TRANSLATE (INVECTOR FRAG1)
T))
(T (CAR FRAG1))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS RECOGNIZE:CONDITIONAL BEING T
IDEN (((@ (@ (@ (MATCH (TUPLE IF FRAG1 THEN ANY1 ELSE ANY2)
LI))))
(PROGN (SETQ SA1 ANY1)
(SETQ SA2 ANY2)
(VECTOR COND (VECTOR (TRANSLATE (INVECTOR FRAG1)
T)
(CADR (TRANSLATE (LIST VECTOR SA1)
T)))
(VECTOR T (CADR (TRANSLATE (LIST VECTOR SA2)
T)))))))
FAST:COMPLEX 1.0)
(PUTPROPS RECOGNIZE:CONJUNCTION BEING T
IDEN (((@ (@ (AND (SETQ PART2 (MEMBER (QUOTE AND)
LI))
(SETQ PART1 (LDIFF LI PART2)))))
(APPEND (VECTOR AND (LIST:TRANSLATE
(COND ((AND (NULL (CDDR (INVECTOR PART1)))
(MATCH (TUPLE A R G ANY3)
(UNPACK (CADR (INVECTOR PART1)))))
(CADR (INVECTOR PART1)))
(T (INVECTOR PART1)))
T))
(COND ((EQUAL (CADR (SETQ FXC (LIST:TRANSLATE (INVECTOR (CDR PART2))
T)))
(QUOTE AND))
(COND ((CDDDR FXC)
(CDDR FXC))
(T (CADDR FXC))))
(T (LIST (COND ((AND (NULL (CDDR FXC))
(MEMBER (CADR FXC)
(TUPLE ARG1 ARG2 ARG3)))
(CADR FXC))
(T FXC))))))))
FAST:COMPLEX 1.0)
(PUTPROPS RECOGNIZE:EQUALITY BEING T
IDEN (((@ (AND (SETQ PART2 (MEMBER EQUALS LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER ISNT LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR NOT (VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T))))
((@ (AND (SETQ PART2 (MEMBER DOESNT LI))
(EQUAL (CADR PART2)
EQUAL)
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDDR PART2))
T))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS RECOGNIZE:FUNCTION:RETURNS BEING T
IDEN (((MATCH (TUPLE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((MATCH (TUPLE THE RESULT OF ANY1)
LI)
(COND ((CADR (SASSOC LI RESULT:BINDING:LIST)))
((SETQ XTEMP (SASSOC ANY1 TRUE:FN:CALL:LIST))
(INVECTOR XTEMP))
((LISTP ANY1)
(INVECTOR ANY1))
((LIST VECTOR ANY1))))
((MATCH (TUPLE THE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((AND (MATCH (TUPLE R E S U L T : FRAG1)
(UNPACK (CAR LI)))
(EQUAL (LENGTH LI)
1))
(CAR LI)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS RECOGNIZE:INCLUSION BEING T
IDEN (((@ (@ (AND (SETQ PART2 (MEMBER (QUOTE IN)
LI))
(SETQ PART1 (LDIFF LI PART2))
(SETQ NEGAT (CAR (LAST PART1)))
(MEMBER NEGAT (TUPLE IS ISNT))
(NOT (EQUAL (QUOTE WHICH)
(CADR (REVERSE PART1)))))))
(VECTOR (COND ((EQUAL NEGAT (QUOTE IS))
@)
(T (QUOTE NOT)))
(VECTOR MEMBER (TRANSLATE (INVECTOR (PULLOUT NEGAT PART1))
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS RECOGNIZE:LITERALS BEING T
IDEN (((Z@ (OR (AND (MATCH (TUPLE ANY1)
LI)
(OR (NUMBERP ANY1)
(MEMBER ANY1 PRIMITIVE:VARS:LIST)
(MEMBER ANY1 (FLATTEN TRUE:FN:CALL:LIST))
(AND (LISTP ANY1)
(MEMBER (CAR (OUTVECTOR ANY1))
(TUPLE COMMENT STRUCTURE)))
(PROGN (PUPRINT (TUPLE IS (@ ANY1)
A LITERAL CONSTANT
(TUPLE WHOSE VALUE SHOULD BE ITSELF)
(TUPLE REPLY YES OR NO, PLEASE)
USER...))
(MEMBER (PREAD)
(QUOTE (YES Y PROBABLY))))))
(AND (LISTP LI)
(MEMBER (CAR (OUTVECTOR LI))
(TUPLE COMMENT QUOTE STRUCTURE)))
(AND (GREATERP (LENGTH LI)
1)
(SETQ ANY1 (TRANSLATE (COLON:BACK LI)
T)))))
(COND ((ATOM ANY1)
(SETQ GLOBAL:INITIALIZATION:LIST (CONS (LIST (QUOTE SETQQ)
ANY1 ANY1)
GLOBAL:INITIALIZATION:LIST))
(COND ((NOT (MEMBER ANY1 PRIMITIVE:VARS:LIST))
(SET ANY1 ANY1))))
(T ANY1)))
((@ (AND (EQUAL (LENGTH LI)
1)
(MEMBER (CAR LI)
PRIMITIVE:VARS:LIST)))
(CAR LI)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
POST:REQUISITES ((VECTOR GLOBAL INITIALIZATION ANY1))
FAST:COMPLEX .14)
(PUTPROPS RECOGNIZE:NUMBER BEING T
IDEN (((MATCH (TUPLE THERE ARE LESS THAN ANY1 THINGS IN FRAG1)
LI)
(PROG (AN1 FR1 FR2 FR3)
(SETQ AN1 ANY1)
(SETQ FR1 FRAG1)
(SETQ FR2 (CDR (MEMBER (QUOTE ,)
FR1)))
(SETQ FR3 (LDIFF FR1 (MEMBER (QUOTE ,)
FR1)))
(RETURN (VECTOR LESSP (VECTOR LENGTH (VECTOR APPEND (LIST:TRANSLATE
(INVECTOR FR3)
T)
(LIST:TRANSLATE (INVECTOR FR2)
T)))
(@ AN1))))))
FAST:COMPLEX 1.0)
(PUTPROPS RECOGNIZE:SET:RELATIONS BEING T
IDEN (((MATCH (TUPLE ANY1 WHICH IS NOT IN ANY2)
LI)
(PROGN (SETQ SANY2 ANY2)
(VECTOR SETDIFFERENCE (TRANSLATE (LIST VECTOR ANY1)
T)
(TRANSLATE (LIST VECTOR SANY2)
T))))
((MATCH (TUPLE ANY1 WHICH IS IN ANY2)
LI)
(PROGN (SETQ SANY2 ANY2)
(VECTOR SETINTERSECTION (TRANSLATE (LIST VECTOR ANY1)
T)
(TRANSLATE (LIST VECTOR SANY2)
T))))
((MATCH (TUPLE ANY1 WHICH IS NOT IN ANY OF FRAG1)
LI)
(PROGN (SETQ HFRAG1 (PULLOUT (QUOTE OR)
FRAG1))
(VECTOR SETDIFFERENCE (TRANSLATE (LIST VECTOR ANY1)
T)
(APPEND (VECTOR APPEND)
(MAPCAR HFRAG1 (FUNCTION (LAMBDA (SA2)
(TRANSLATE
(LIST VECTOR SA2)
T)))))))))
FAST:COMPLEX 1.0)
(PUTPROPS RECOGNIZE:SOME:MEMBER BEING T
IDEN (((MATCH (TUPLE SOMETHING IN FRAG1)
LI)
(VECTOR CAR (TRANSLATE (INVECTOR FRAG1)
T)))
((MATCH (TUPLE EVERYTHING IN FRAG1)
LI)
(TRANSLATE (INVECTOR FRAG1)
T))
((AND (EQUAL (CAR LI)
(QUOTE THOSE))
(SETQ LI2 (CDR (MEMBER (QUOTE WHICH)
LI)))
(SETQ LI1 (CDR (SETDIFFERENCE LI (MEMBER (QUOTE WHICH)
LI))))
(SETQ LI1 (COLON:BACK (CONS (QUOTE SET:OF)
LI1))))
(VECTOR MAPCONC (@ LI1)
(VECTOR FUNCTION (VECTOR LAMBDA (VECTOR LS)
(VECTOR COND
(VECTOR (INVECTOR
(TRANSLATE (INVECTOR LI2)
T))))))))
((MATCH (TUPLE ANY ANY1 ESPECIALLY ONE WHICH HAS JUST BEEN ANY2)
LI)
(VECTOR RANDOMSELECT (COLON:BACK (LIST (PLURAL ANY1)
ANY2))
(PACK (TUPLE SET:OF: (PLURAL ANY1))))))
FAST:COMPLEX 1.0)
(PUTPROPS RECOGNIZE:TAIL BEING T
IDEN (((MATCH (TUPLE ALL BUT THE FIRST ANY1 ELEMENTS OF ANY2)
LI)
(VECTOR (PACK (APPEND (TUPLE C)
(FIRSTN ANY1 (TUPLE D D D D))
(TUPLE R)))
(LIST:TRANSLATE (INVECTOR ANY2)
T))))
FAST:COMPLEX 1.0)
(PUTPROPS REINVESTIGATE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (OR (MEMBER D DEFERRED:DECISION:LIST)
(EQUAL (CADDDR D)
(VECTOR BECAUSE OF DIRECT COMMAND)))
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE; FIRST TRY TO DEFER IT A LITTLE LONGER)
HOW (VECTOR TRY TO DEFER (CADDR D)
;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;ELSE ASK THE USER TO
RESOLVE IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADDR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ D)))))
META:CODE (PROGN (SETQ DEFERRED:DECISION:LIST (PULLOUT D DEFERRED:DECISION:LIST))
(SETQ UNDEFERRED:DECISION:LIST (CONS (CADR D)
UNDEFERRED:DECISION:LIST))
(DEFER:DECISION (CADR D)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T
FAST:COMPLEX .14)
(PUTPROPS REPEATEDLY BEING T
EXPLICIT:ARGS (ACT1 ACT2 ACT3 ACT4)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE DO ACTIONS OVER AND OVER)
HOW (TUPLE CONVERT THE SINGLE FUNCTION CALL INTO AN INFINITE ITERATIVE LOOP)
WHY (TUPLE THIS IS EASIER, SURER, AND OFTEN FASTER THAN RECURSION)
META:CODE (PROGN (VECTOR SEE THE FORM:CHANGING SECTION)
(SETQ F1 (APPEND (TUPLE REPEATEDLY)
ACT1 ACT2 ACT3 ACT4))
(EVAL (GETP REPEATEDLY FORM:CHANGING)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FORM:CHANGING (PROGN (SETQ F1 (APPEND (TUPLE PROG NIL (SETQ TEMPL (COLON:BACK
(TUPLE LABEL (SETQ LABEL:COUNTER
(ADD1
LABEL:COUNTER)))))
)
(CONS (PROG1 (SETQ C1 (GETCODE (CADR F1)
FNAME 0))
(COND ((NUMBERP (CAR (LAST (COLON:BREAK
C1))))
(SETQ
TRUE:FN:CALL:LIST
(CONS (OUTVECTOR
(CONS C1 (CDDR F1)))
TRUE:FN:CALL:LIST)))))
(GETCODE (CDDR F1)
FNAME 1))
(TUPLE (LIST GO TEMPL)
(TUPLE COMMENT INFINITE LOOP IN THIS PROG))))
(SETQ CODING:WARNING:LIST (CONS (TUPLE 101 VECTOR INFINITE LOOP IN
(@ FNAME)
FROM
(@ TEMPL)
TO
(LIST VECTOR GO TEMPL))
CODING:WARNING:LIST))
F1)
IMPLICIT:ARGS (F1)
FAST:COMPLEX .14)
(PUTPROPS RESOLVE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1 ENT2 ENT1 TRESULT NEWPIECE)
EXPLICIT:ARGS (D STAG)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE)
HOW (VECTOR TRY TO RESOLVE (CADR D)
WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK THE USER ABOUT IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (@ D)
SINCE
(VECTOR DIRECT COMMAND)))))
META:CODE (COND ((MEMBER (CADR D)
RESOLVED:DECISION:LIST)
T)
(T (SETQ RESOLVED:DECISION:LIST (CONS (VECTOR (CADR D)
IS RESOLVED AS
(INVECTOR (ASK:USER:ABOUT
D)))
RESOLVED:DECISION:LIST))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T
FAST:COMPLEX .14)
(PUTPROPS SATISFY BEING T
IDEN (((AND (EQUAL (CAR LI)
FAST:SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR FAST:SATISFY (TRANSLATE (CADR LI)
T))))
IMPLICIT:ARGS (TEMP:LIST EV:G)
EXPLICIT:ARGS (G FORCE:SAT)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE FAST:SATISFY THE SIMPLE SUBGOAL (@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
MAIN:EFFECTS (((VECTOR PUP SATISFIED ANY1)
(VECTOR FAST:SATISFY (@ ANY1))))
META:CODE (COND ((AND (MEMBER EV:G (FIRSTN 90 (EVAL (SETQ TEMP:LIST
(COLON:BACK (COPY (LIST (CADR G)
(CADDR G)
(QUOTE LIST)))))))
)
(NOT FORCE:SAT)))
(T (SOME EFFECTS:TABLE (FUNCTION (LAMBDA (E1)
(AND (MATCH (CAR E1)
G)
(EVAL (CDR (EVAL (CADR E1))))))))
(SETQ BECAUSE (VECTOR WE CALL THE FIRST BEING WHICH CAN BRING ABOUT THE EFFECT
(@ G)))
(COND ((MEMBER EV:G (EVAL TEMP:LIST))
(SETQ PUP:SATISFIED:LIST (CONS G PUP:SATISFIED:LIST)))
((MEMBER G USER:WARNING:LIST)
NIL)
(T (PUPRIN1 "
WARNING: SATISFY IS SHAKING ITS HEAD ABOUT THIS ONE:")
(PUPRIN1 G)
(SETQ USER:WARNING:LIST (CONS G USER:WARNING:LIST))
NIL))))
COMMENTS ((SETQ G (EVAL G))
(SETQ EV:G (EVAL (CADDDR G))))
AFFECTS (APPEND (MAPCAR (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA
(E1)
(COND ((MATCH (CAR E1)
G)
(SETQ
B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(RETURN B:LIST))
(FUNCTION (LAMBDA (Y)
(COND (Y (CONS Y (QUOTE (POSSIBLE:CALLED))))))))
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED))))
COMPLEXITY:VECTOR (0.0 .3 .2 .4 .1)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM ADAPT:PRECONCEIVED:FUNCTION)
INHIBIT:CURRENT:DEMONS T
FAST:COMPLEX .114)
(PUTPROPS SCENE BEING T
META:CODE (STRUCTURE (OBJECTS SET O)
(CLASS:NAME NAME N)
(STATIC RELATIONS S BETWEEN OBJECTS)
(DYNAMIC RELATIONS D BETWEEN OBJECTS))
IDEN (((EQUAL LI (LIST SCENE))
(VECTOR SCENE)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
DATA:STRUCTURE T
FAST:COMPLEX .14)
(PUTPROPS SEARCH BEING T
EXPLICIT:ARGS (GOAL SPACE)
EXPLICIT:ARGS:CHECK SPACE
WHAT (TUPLE SEARCH THROUGH A KNOWN, FINITE SPACE (@ SPACE)
FOR AN ELEMENT SATISFYING THE GOAL (@ GOAL))
HOW (TUPLE EXAMINE MEMBER OF SPACE TO SEE IF IT MEETS CRITERIA)
WHY (TUPLE BECAUSE PUP MUST GET A MEMBER OF (@ SPACE)
WHICH SATISFIES (@ GOAL))
META:CODE ($
(COND
((OR
(SETQ SH NIL)
(PROGN (SATISFY (VECTOR IS CONSTRAINED (SET XSET XSET)))
(NOT (SETQ CL (CADR (SASSOC XSET IS:CONSTRAINED:LIST)))))
(GREATERP (LENGTH CL)
2)
(COND
((SETQ SH (SOME RESULT:BINDING:LIST (FUNCTION (LAMBDA (RB)
(MATCH (VECTOR
(@ XSET)
SEARCH PREDICATE
IS ANY1)
RB)))))
NIL)
(T
(PUPRIN1
(CONCAT
"
DOES THERE EXIST A PREDICATE WHICH IS TRUE PRECISELY WHEN AN ELEMENT
IS "
(CAR CL)
" AND IS NIL IFF THE ELEMENT IS "
(CADR CL)
"?
USER: (YES OR NO, FOR NOW......) "))
(MEMBER (PREAD)
(TUPLE N NO NIL)))))
(INSTANTIATE (QUOTE (PROGN (FOREACH ($ X)
IN
($ XSET)
DO
($ (TUPLE TEST (@ X)
(COMMENT FOR SATISFACTION OF GOAL
CRITERIA))))
(PUPRIN1 "
MY GUESS FOR THIS IS ")
(PUPRINT ($ X))))))
(T (COND (SH (SETQ CP (CAR (LAST (CAR SH)))))
(T (PUPRIN1 (CONCAT "
OK. NOW GIVE ME THIS PREDICATE, IN TERMS OF " (MOST:GENERAL NEW:THING:LIST)
"
I SUGGEST THAT THIS INVOLVES ONE OF THESE: " PROBABLE:TESTS:LIST "
USER: "))
(SETQ CP (TRANSLATE (INVECTOR (PREAD))
T))
(SETQ RESULT:BINDING:LIST (NCONC1 RESULT:BINDING:LIST (VECTOR
(@ XSET)
SEARCH PREDICATE IS (@ CP))))
(SETQ GLOBAL:INITIALIZATION:LIST (APPEND GLOBAL:INITIALIZATION:LIST
(MAPCAR CL
(FUNCTION
(LAMBDA
(CLE)
(LIST (QUOTE SETQQ)
CLE CLE))))))))
(TUPLE PROGN (LIST (QUOTE SETQ)
X
(TUPLE COND (LIST (OUTVECTOR CP)
(CAR CL))
(LIST T (CADR CL))))
(TUPLE PUPRIN1 "
MY GUESS FOR THIS IS ")
(TUPLE PUPRINT (@ X))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS ((COMMENT HER WE MUST NOTE THE TERMINATION CONDS.))
ALTERNATIVES (TUPLE GENERATE:AND:TEST COMPUTE)
IMPLICIT:ARGS (X XSET)
COMMENTS ((PROGN (DETERMINE:ARG:VALUE CHOICE)
(SETQ X (COND ((EQUAL POSSIBLE (CAR (COLON:BREAK ARG1)))
ARG1)
((COLON:BACK (LIST POSSIBLE ARG1)))))
(SETQ XSET (COLON:BACK (LIST SET:OF (PLURAL X))))))
FAST:COMPLEX .14)
(PUTPROPS SERVE IDEN (((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE)))
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
META:CODE (PROG NIL (SETQ UNKNOWN:TASK NON:EXECUTABLE)
(SETQ BECAUSE (VECTOR THE CURRENT TASK (@ UNKNOWN:TASK)
IS NOT EXECUTABLE AND WE HAVE NOTHING ELSE TO DO AT THE PRESENT
TIME))
LABEL6
(COND ((NOT (MEMBER UNKNOWN:TASK EXECUTABLE:INFO:LIST))
(MAPC USER:INTERRUPT:DEMONS (QUOTE APPLY*))
(OBTAIN:USABLE:INFORMATION (QUOTE UNKNOWN:TASK))
(GO LABEL6)))
(SETQ ATTEMPTING:SOMETHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:SOMETHING:LIST))
(SETQ ATTEMPTING:ANYTHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:ANYTHING:LIST))
(SETQ BECAUSE (VECTOR WE FINALLY HAVE AN EXECUTABLE TO TASK TO DO, NAMELY
(@ UNKNOWN:TASK)))
(SETQ EXECUTABLE:INFO:LIST NIL)
(EVAL (CDR UNKNOWN:TASK)))
COMMENTS ((SETQ PUP:WANTS:LIST (CONS (VECTOR ANY TASK)
PUP:WANTS:LIST)))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP WANTS ANY TASK)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE)))
COMPLEXITY:VECTOR (.2 .4 .6 .8 .1)
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
DEMONS (TUPLE FORGETFUL:USER:DEMON)
FAST:COMPLEX .134)
(PUTPROPS SIMPLE:COMPARE:FN BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE QUASI-COMPARISON WHICH ALWAYS RETURNS A CONSTANT VALUE)
HOW (TUPLE GET THE VALUE ONCE, AND ALWAYS RETURN IT)
WHY (TUPLE BECAUSE ORDERING ISNT VERY IMPORTANT HERE)
META:CODE (PROGN (ASK:USER:ABOUT VALUE))
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
GENERALIZATIONS (TUPLE BETTER)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(QUOTE (VECTOR (VECTOR PUT EACH NEW ELEMENT ON AT THE
FRONT)
(VECTOR PUT EACH NEW ELEMENT ON AT THE
REAR)
(ERROR!)))
AFFECTS
(VECTOR THE SIMPLE:COMPARE:FN ALGORITHM)
RESULTS
(VECTOR (VECTOR PROGN
(COMMENT THIS ALLOWS MERGE TO BE THE SAME
AS CONS)
NIL)
(VECTOR PROGN
(COMMENT THIS ALLOWS MERGE TO BE THE SAME
AS NCONC1)
T))
SIMPLE:COMPARE:FN))
PREDICATE T
FAST:COMPLEX .13)
(PUTPROPS SOME:PART:OF BEING T
EXPLICIT:ARGS (LIST:STRUC)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE THIS IS A DESTRUCTIVE FUNCTION; IT BREAKS A PIECE OFF OF (@ LIST:STRUC))
HOW (TUPLE USE SOME PRE:EXISTING TECHNIQUE TO GET THE SIMPLE LISP PROGRAM
(TUPLE MADE UP OF CARS AND CDRS)
WHICH DOES THE JOB. SUCH FACILITIES MIGHT BE PW1, PUP, DAVID SHAW'S PGM, OR EVEN
TRIAL AND ERROR.)
WHY (TUPLE ONLY PART OF (@ LIST:STRUC)
IS DESIRED AT THIS POINT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .9)
GENERALIZATIONS (TUPLE FUNCTION SUBROUTINE PROGRAM SYSTEM)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(QUOTE (PROGN (VECTOR WE GET THE SOME:PART:OF FUNCTION (CADR CHOICE)
BY EXAMPLE I/O)
(VECTOR WE GET THE SOME:PART:OF FUNCTION (CADR CHOICE)
BY TRANSLATING AN EXPLICITLY USER-PROVIDED SENTENCE)
(ERROR!)))
RESULTS
(VECTOR
(QUOTE (LEARN:BY:EXAMPLE (VECTOR SOME:PART:OF (CADR CHOICE)
(@ ARG1)
(@ ARG2))))
(QUOTE
(PROGN
(PUPRIN1
"
OK, NOW TYPE IN THE SENTENCE EQUIVALENT TO THE ACTION OF THE
SOME:PART:OF:FUNCTION IN QUESTION
USER: ")
(TRANSLATE (INVECTOR (PREAD))
T))))
AFFECTS
(VECTOR THE SOME:PART:OF ALGORITHM)
SOME:PART:OF))
IDEN (((MATCH (TUPLE SOME PART OF ANY1)
LI)
(VECTOR SOME:PART:OF (CADR (TRANSLATE (LIST VECTOR ANY1)
T))))
((MATCH (TUPLE SOME ELEMENTS OF ANY1)
LI)
(VECTOR SOME:PART:OF (CADR (TRANSLATE (LIST VECTOR ANY1)
T)))))
FAST:COMPLEX .86)
(PUTPROPS STRING BEING T
IDEN (((EQUAL LI (LIST STRING))
(VECTOR STRING)))
WHAT (TUPLE A STRING OF LETTERS, WITH A NAME AND COMMENTS)
HOW (TUPLE USE THE LIST STRUCTURE OF LISP VARIABLES TO HOUSE THE 3 PARTS)
WHY (TUPLE BECAUSE THE PARTS WILL PROBABLY BE ACCESSED THROUGH ONLY ONE OR TWO OF THE THREE
DIVISIONS)
META:CODE (STRUCTURE (CLASS:NAME NAME N)
(LETTERS STRING L)
(COMMENTED LIST C))
COMPLEXITY:VECTOR (.3 .3 .3 .3 .1)
GENERALIZATIONS (TUPLE LIST:STRUCTURE)
SPECIALIZATIONS (TUPLE LIST:OF:ATOMS)
ALTERNATIVES (TUPLE SCENE)
DATA:STRUCTURE T
FAST:COMPLEX .12)
(PUTPROPS STUDY:TYPE BEING T
IDEN (((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI))))
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK (OR (GETP (CADR B:CALL)
BEING)
(PUPRINT (COMMENT (CADR B:CALL)
IS NOT A BEING YET)))
WHAT (TUPLE INVESTIGATE THE VARIOUS SPECIALIZATIONS OF (@ B:CALL))
HOW (TUPLE TRANSFER THE SPECIALIZATIONS (GETP (CADR B:CALL)
SPECIALIZATIONS)
OF
(@ B:CALL)
ONTO THE LIST OF DECISIONS WHICH MUST BE ATTENDED TO)
WHY (TUPLE BECAUSE THE MORE SPECIFIC OUR KNOWLEDGE OF WHAT IS WANTED, THE MORE EASILY AND
COMPLETELY WE MAY SATISFY THAT REQUEST)
MAIN:EFFECTS (((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1))))
META:CODE (PROGN (MAPC (CDR (GETP (CADR B:CALL)
SPECIALIZATIONS))
(FUNCTION (LAMBDA (A)
(SETQ UNDEFERRED:DECISION:LIST
(NCONC1 UNDEFERRED:DECISION:LIST
(COND ((ATOM A)
A)
((ATOM (CAR A))
(EVAL A))
((APPLY* (EVAL (CAR A))
B:CALL))))))))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR TYPE OF (@ B:CALL))
PUP:STUDIED:LIST))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
HAS BEEN STUDIED)
TYPE:OF:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS SUPPORT&DUMP BEING T
EXPLICIT:ARGS (F)
EXPLICIT:ARGS:CHECK (AND (MEMBER F IS:BEING:LIST))
WHAT (TUPLE GATHER UP SUPPORTING BEINGS AND DUMP OUT (@ F)
SYSTEM)
HOW (TUPLE FOR NOW, GATHER UP ALL BEINGS!!)
WHY (TUPLE EXPEDIENCY)
META:CODE (PROGN (SET (PACK (LIST (CAR (COLON:BREAK F))
(QUOTE FNS)))
(LIST START))
(SET (PACK (LIST (CAR (COLON:BREAK F))
(QUOTE COMS)))
(TUPLE (TUPLE FNS * (PACK (LIST (CAR (COLON:BREAK F))
(QUOTE FNS))))
SET:OF:BEINGS IS:BEING:LIST ASSERT:LISTS
GLOBAL:INITIALIZATION:LIST OLD:PREADLIST SB EXPERTAG YESNO:TAG
TASK:TYPE ARG1 ARG2
(QUOTE (COMS * (LIST (APPEND (QUOTE (PROP ALL))
(SETDIFFERENCE IS:BEING:LIST SB)))))
(TUPLE P (QUOTE (MAPC (SETDIFFERENCE IS:BEING:LIST SB)
(FUNCTION (LAMBDA (B)
(SET B B)
(SEMI:COMPILE B)))))
(QUOTE (MAPC GLOBAL:INITIALIZATION:LIST (QUOTE EVAL)))
(TUPLE PRINT (COMMENT TO AUTOMATICALLY ENTER THE FUNCTION
(@ F)
,JUST TYPE IN A CALL TO THE FUNCTION
ENTER. THIS WILL INITIALIZE THE
ENTIRE BEINGS SYSTEM AND THEN CALL
(@ F))))))
(COND ((EQUAL (CAR (QUOTE DIALOG))
(QUOTE NOBIND))
(PRIN1 "
WHAT IS 'DIALOG' (WILL BE EVALLED) ? ")
(SETQ DIALOG (EVAL (READ)))))
(SETQ GLOBAL:INITIALIZATION:LIST
(APPEND GLOBAL:INITIALIZATION:LIST
(MAPCONC IS:CONSTRAINED:LIST
(FUNCTION (LAMBDA (IC)
(COND ((LISTP IC)
(LIST (TUPLE SETQQ
(CAR IC)
(CADR IC)))))))))
)
(SETQ GLOBAL:INITIALIZATION:LIST (MAPCONC GLOBAL:INITIALIZATION:LIST
(FUNCTION (LAMBDA (GL)
(COND
((CADR GL)
(LIST GL)))))))
(MAPC GLOBAL:INITIALIZATION:LIST (QUOTE EVAL))
(LOADFNS (LIST START)
(QUOTE PUP6)
T)
(PUTD START (COPY (SUBST (LIST F)
(TUPLE SERVE)
(COPY (GETD START)))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(PUT B META:CODE (CHECK:COMMENTS (GETP B META:CODE))))
))
(SETQ OP OLD:PREADLIST)
(SETQ SB SET:OF:BEINGS)
(SETQ GLOBAL:INITIALIZATION:LIST (INTERSECTION GLOBAL:INITIALIZATION:LIST
GLOBAL:INITIALIZATION:LIST))
(SETQ SET:OF:BEINGS IS:BEING:LIST)
(SETQ ASSERT:LISTS (PULLOUT1 (QUOTE GLOBAL:INITIALIZATION:LIST)
ASSERT:LISTS))
(MAPC (SETDIFFERENCE IS:BEING:LIST SB)
SEMI:COMPILE)
(COND ((PERMIT:USER:INTERRUPT)
(SETQ OLD:PREADLIST (CONS (CAR OLD:PREADLIST)
DIALOG))
(MAKEFILE (CAR (COLON:BREAK F)))))
(SETQ OLD:PREADLIST OP)
(SETQ SET:OF:BEINGS SB)
(SETQ ASSERT:LISTS (CONS (QUOTE GLOBAL:INITIALIZATION:LIST)
ASSERT:LISTS))
(PUTD START (COPY (SUBST (TUPLE SERVE)
(LIST F)
(COPY (GETD START))))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR FILE (CAR (COLON:BREAK F))
HAS BEEN MADE AND WILL SUPPORT BEING (@ F))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .5)
IMPLICIT:ARGS (OP)
FAST:COMPLEX .5)
(PUTPROPS TAKE:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TAKE THE ENTITY (@ ENTITY)
IN A TRIVIAL WAY; EITHER BY ACCESSING IT OR BY READING IT IN)
HOW (TUPLE LOOK AROUND A LITTLE; IF IT ISNT FOUND TRIVIALLY, THEN ASK THE USER TO GIVE
(@ ENTITY)
TO US)
WHY (TUPLE PUP WANTS (@ ENTITY)
,AND WE DON'T HAVE TO DO ANY COMPUTING TO GET IT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(QUOTE (AND (SETQQ QUALIFIER BRAND)
(FLOW:PRECEDED (VECTOR SETQ (@ ARG1)
ANY1))
(SETQQ QUALIFIER CORRECT)
(PUPRINT (TUPLE THE ASSIGNMENT WHICH SET (@ ARG1)
,NAMELY
(@ FLOW:ASSIGNMENT)
,WAS DONE EARLIER; SHOULD A NEW VALUE OF
(@ ARG1)
BE PREAD IN AT THIS POINT IN THE PROGRAM FLOW?
USER...))
(MEMBER (PREAD)
(VECTOR NIL NO N))
T))
AFFECTS
(VECTOR THE TAKE:HOLD:OF ALGORITHM)
RESULTS
(VECTOR
(QUOTE (TUPLE PROGN
(COMMENT NOTHING MUCH TO DO HERE; JUST ONE SIMPLE
ASSIGNMENT TO AN ALREADY EXISITNG VALUE)
(VECTOR SET ARG1
(PROG1 (SETQ KN (COLON:BACK (TUPLE OBVIOUS KNOWN
VALUE OF
(@ ARG1))))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 101 VECTOR COMMENT
WARNING (@ KN)
IN
(CADR CHOICE)
UNDEFINED; WILL BE
GOTTEN LATER; PROBABLY
SOME JUST-READ-IN VALUE
SINCE
(COMMENT I KNOW I NEED
NOT DO ANY REAL
WORK TO GET IT))
CODING:WARNING:LIST))))))
(QUOTE
(APPEND
(TUPLE PROGN (VECTOR PUPRINT (TUPLE COMMENT READY TO ACCEPT
(@ QUALIFIER)
NEW
(@ ARG1)))
(VECTOR SET ARG1 (TUPLE PREAD)))
(MAPCAR (CDR (GETP (@ ARG1)
META:CODE))
(FUNCTION
(LAMBDA
(EPART TCODE)
(SETQQ NEWNAME NEWNAME)
(PUPRINT (TUPLE PUP IS ABOUT TO ENCODE AN ASSIGNMENT:
(@ EPART)
WILL BE SET TO SOME PART OF ARG1 WHICH
IS GOING TO BE INSTANTIATED DURING THE
RUNNING OF THE PROGRAM AS (@ ARG1)
.PUP WANTS A NAME FOR THIS 'SOME PART
OF' FUNCTION.))
(SETQ ARG:LIST (CDR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST)))
(SETQ TCODE (GETCODE (TUPLE SETQ (COLON:BACK EPART)
(TUPLE SOME:PART:OF
(TUPLE EVAL ARG1)))
(CADR CHOICE)
-1))
(SETQ NEW:ACCESS (TUPLE (CAAR (LAST TCODE))
X))
(PUT ARG1 DATA:STRUCTURE
(COND ((SETQ AC1 (CADR (MEMBER (QUOTE ACCESS)
(GETP ARG1
DATA:STRUCTURE))))
(COPY (SUBST (CONS (TUPLE (@ NEW:ACCESS)
ACCESSES
(@ EPART))
AC1)
AC1
(COPY (GETP ARG1 DATA:STRUCTURE)
))))
(T (TUPLE ACCESS (TUPLE (LIST NEW:ACCESS
(QUOTE ACCESSES)
EPART))))))
(SETQ NEW:THING:LIST (CONS (CADR TCODE)
NEW:THING:LIST))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR TCODE)
TYPE OF (CONS VECTOR
EPART)
IS USED IN THE
ASSIGNMENT STATEMENT
(@ TCODE)
IN
(CADR CHOICE))
TYPE:OF:LIST))
TCODE)))
(PROGN (SETQ NEW:THING:LIST (CONS (@ ARG1)
NEW:THING:LIST))
(LIST T)))))
TAKE:HOLD:OF))
NLAMBDA T
FAST:COMPLEX .14)
(PUTPROPS TEST BEING T
EXPLICIT:ARGS (ENTITY DESCRIPTION:OF:CONDITION)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TEST TO SEE IF THE ENTITY (@ ENTITY)
MEETS THE DESIRED CONDITIONS (@ DESCRIPTION:OF:CONDITION))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(QUOTE (PROGN (VECTOR THE TESTING MAY HAVE THE CHARACTER OF COMPARING
THE OBJECT (VECTOR THAT IS, ARG1, ALSO KNOWN AS
(TUPLE TUPLE CADDR ENT1))
WITH SOME DISTINGUISHED OBJECT)
(VECTOR TESTING MAY HAVE THE CHARACTER OF LETTING THE
OBJECT (VECTOR WHICH IS ARG1)
COMPETE WITH ITS FELLOW OBJECTS FOR SUPREMACY)
(COND ((INFER:INSIDE (CADR CHOICE)
FOREACH)
T)
((INFER:INSIDE (CADR CHOICE)
EXTREMUM)
NIL)
(T (ERROR)))))
AFFECTS
(VECTOR THE TEST ALGORITHM)
RESULTS
(VECTOR (VECTOR COMPARE ARG1 (MOST:GENERAL NEW:THING:LIST))
(VECTOR REPEATEDLY (VECTOR COMPARE ARG1 CURRENT:BEST:ARG1)
(VECTOR REVISE CURRENT:BEST:ARG1)))
COMMENT
(COMMENT THE "DISTINGUISHED OBJECT" IS ASSUMED TO BE A NEWLY-ACQUIRED
ONE, PROBABLY JUST PREAD IN. IT WILL BE ONE OF THESE:
(@ NEW:THING:LIST)
;PROBABLY THIS ONE: (MOST:GENERAL NEW:THING:LIST)
%. "COMPETING" MEANS THAT EACH ARG1 IS COMPARED WITH THE
PARTICULAR OLD ARG1-VALUE WHICH HAS
(VECTOR SO FAR, AT LEAST)
RECEIVED THE HIGHEST RATING; I.E., DEFEATED ALL CHALLENGERS.
THUS, THE ARG1-VALUE RETAINED AT THE END SHOULD BE THE BEST
ONE. THIS PRESUPPOSES THAT THE COMPARISON FUNCTION IS
TRANSITIVE.)
TEST)
(VECTOR ALTERNATIVES (VECTOR NOMINAL:RESULT ORDINAL:RESULT RATIO:RESULT)
AFFECTS
(VECTOR WHETHER NO OTHER, ALL OTHER, OR ALL OTHER OBJECTS MUST BE
EXAMINED)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO TEST (TUPLE TUPLE CADDR ENT1))
TEST))
FAST:COMPLEX .14)
(PUTPROPS TRANSLATE IDEN (((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO FORCE:TRANSLATE)
WHAT (TUPLE TRANSLATE A PIECE OF UNTRANSLATED NEW INFORMATION)
HOW (TUPLE TRANSFORM (@ NEW:INFO)
INTO MORE EXECUTABLE FORM)
WHY (TUPLE EW INFORMATION (@ NEW:INFO)
IS DECLARATIVE AND MUST BE MADE PROCEDURAL BEFORE IT MAY BE USED BY THE SYSTEM)
WHEN ((T (COND (USABLE:INFO:LIST -60)
(T 50))
(QUOTE (BECAUSE THE ABSENCE OF USABLE INFORMATION ABDUCTIVELY CALLS FOR ITS PRODUCTION;
ITS PRESENCE DEMANDS ITS ASSIMILATION)))
((MEMBER (EVAL NEW:INFO)
TRANSLATED:INFO:LIST)
-111
(VECTOR BECAUSE WE HAVE ALREADY TRANSLATED IT IMPLIES WE SHOULDNT NOW)))
META:CODE (PROG (LI TEMPTR)
(SETQ LI (CDR EV:NEW:INFO))
(SETQ NEW:INFO:LIST (PULLOUT EV:NEW:INFO NEW:INFO:LIST))
(MAPC IDEN:TABLE (FUNCTION (LAMBDA (II)
(COND ((EVAL (CAR II))
(COND ((SETQ TEMPTR
(EVAL (CADR II)))
(SETQ TRANSLATED:PAIR:LIST
(CONS (LIST EV:NEW:INFO
TEMPTR)
TRANSLATED:PAIR:LIST)
)
(SETQ TRANSLATED:INFO:LIST
(CONS EV:NEW:INFO
TRANSLATED:INFO:LIST))
(COND ((NOT FORCE:TRANSLATE)
(SETQ
EXECUTABLE:INFO:LIST
(CONS TEMPTR
EXECUTABLE:INFO:LIST)))))
)
(RETURN TEMPTR))))))
(PUPRIN1 "SORRY, I T TRANSLATE
PLEA
PLEA")
(PUPRIN1 "
PLEASE RETYPE THE FOLLOWING, REPHRASING IT SO I CAN COMPREHEND IT:
")
(PUPRIN1 EV:NEW:INFO)
(RETURN (TRANSLATE (INVECTOR (PREAD))
T)))
EXPLICIT:ARGS:CHECK (OR (MEMBER (EVAL NEW:INFO)
NEW:INFO:LIST)
(NULL (EVAL NEW:INFO))
FORCE:TRANSLATE
(COND (NEW:INFO:LIST (SETQQ NEW:INFO UNKNOWN:TASK)
(SET NEW:INFO (CAR NEW:INFO:LIST)))))
DEMONS (TUPLE IDIOM:DEMON)
MAIN:EFFECTS (((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1))))
MINOR:EFFECTS ((VECTOR NEW INFO))
AFFECTS (QUOTE ((LOOKUP CALLED)
(PARSE CALLED)))
COMPLEXITY:VECTOR (.3 .5 .5 .5 .1)
COMMENTS ((SETQ EV:NEW:INFO (EVAL NEW:INFO)))
IMPLICIT:ARGS (EV:NEW:INFO PART1 PART2)
FAST:COMPLEX .138)
(PUTPROPS USE:INFORMATION BEING T
IMPLICIT:ARGS (ACTION)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK EXECUTABLE:INFO:LIST
WHAT (TUPLE USE SOME AVAILABLE INFORMATION)
HOW (TUPLE PICK ONE OF (@ EXECUTABLE:INFO:LIST)
AND DO IT)
WHY (TUPLE IF WE DON'T DO WHAT WE CAN AS SOON AS POSSIBLE, WE MIGHT NEEDLESSLY BOTHER THE
USER, OUR SLOWEST CHANNNEL)
WHEN ((EXECUTABLE:INFO:LIST 120
(TUPLE BECAUSE WE COULD BE GOING IN CIRCLES IF WE DON'T DO WHAT
WE CAN AS SOON AS POSSIBLE)))
META:CODE (PROGN (SETQ ACTION (COND ((GETP (CAR (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))
NON:EVAL:ARGS)
(COND ((EQUAL (CAAR EXECUTABLE:INFO:LIST)
VECTOR)
(CDAR EXECUTABLE:INFO:LIST))
(T (CAR EXECUTABLE:INFO:LIST))))
(T (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))))
(SETQ EXECUTABLE:INFO:LIST (CDR EXECUTABLE:INFO:LIST))
(COND ((EVAL ACTION))
(T (NCONC1 EXECUTABLE:INFO:LIST ACTION)
NIL)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS UTILIZE BEING T
IDEN (((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI))))
IMPLICIT:ARGS (KNOW:LIST DEC)
EXPLICIT:ARGS (KNOW:NAME APLIED:SO:AS:TO:KEEP INVARIANT)
EXPLICIT:ARGS:CHECK (AND (EQUAL (CAR INVARIANT)
VECTOR)
(MEMBER (CADR INVARIANT)
(QUOTE (RELEVANT IRRELEVANT)))
(ATOM KNOW:NAME)
(OR (NULL (EVAL KNOW:NAME))
(LISTP (EVAL KNOW:NAME))))
WHAT (TUPLE USE THE LIST (@ KNOW:LIST)
OF INFORMATION TO DECIDE THE TURNING POINT OF THE TRUTH OF THE PREDICATE (@ INVARIANT))
HOW (TUPLE SEARCH THROUGH (@ KNOW:LIST)
FOR APPLICABLE RULES)
WHY (TUPLE SO PUP KNOWS WHEN (@ INVARIANT)
CHANGES TRUTH VALUE)
META:CODE (PROG (AF HOLD:ANY2 KRETURN)
(COND ((MATCH (VECTOR ANY2 (VECTOR PUP REINVESTIGATE FRAG1))
INVARIANT)
(SETQ HOLD:ANY2 ANY2)
(SETQ DEC (CONS VECTOR FRAG1))
(SETQ AF (CADR (MEMBER WHEN DEC)))
(SOME (EVAL (COLON:BACK (CONS WHEN:ALL (CDR (COLON:BREAK KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(SETQ KRETURN (EVAL (CADR K)))
T)))))
(COND (KRETURN (RETURN KRETURN)))
(SETQ AF (CADR (MEMBER AFFECTS DEC)))
(SOME (EVAL (COLON:BACK (CONS AFFECTS:ALL (CDR (COLON:BREAK KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(SETQ KRETURN (EVAL (CADR K))))))))
(COND (KRETURN (RETURN KRETURN)))
(SOME KNOW:LIST (FUNCTION (LAMBDA (K)
(COND ((SETQ AF (EVAL K))
(SETQ KRETURN (VECTOR (OPPOSITE
HOLD:ANY2)
(@ AF))))))))
(COND (KRETURN (RETURN KRETURN)))
(RETURN NIL))
(T (RETURN NIL))))
COMMENTS ((OR (SETQ KNOW:LIST (EVAL KNOW:NAME))
T))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FAST:COMPLEX .14)
(PUTPROPS WHEN:NEXT BEING T
IDEN (((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI))))
IMPLICIT:ARGS (UTILIZATION UTIL2 AWARE:LIST)
EXPLICIT:ARGS (ACT)
EXPLICIT:ARGS:CHECK (AND (MEMBER (CADR ACT)
(QUOTE (USER PUP)))
(EQUAL (LENGTH ACT)
4))
WHAT (TUPLE FIND THE NEXT SITUATION IN WHICH (CADR ACT)
MUST PERFORM THE OPERATION (CADDR ACT)
ON
(CADDDR ACT))
HOW (TUPLE EXPLORE THE EFFECTS OF (CADDR ACT)
ING
(CADDDR ACT))
WHY (TUPLE (CADR ACT)
CAN THEN FORGET (CADDDR ACT)
UNTIL THE NEXT SITUATION WE FIND HERE)
MAIN:EFFECTS (((VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2)))))
META:CODE (PROGN (SETQ RELEVANT:KNOWLEDGE (COLON:BACK (COPY (TUPLE (CADR (CADDDR ACT))
(CADR BEING:STACK)
KNOWLEDGE))))
(SETQ UTILIZATION (VECTOR DELAYABLE (@ ACT)
UNTIL
(SETQ UTIL2 (UTILIZE
RELEVANT:KNOWLEDGE APPLIED:SO:AS:TO:KEEP
(VECTOR IRRELEVANT (APPEND
(VECTOR (CADR ACT)
(CADDR ACT))
(CDDAR (CDDDR ACT))))))))
(SETQ AWARE:LIST (COLON:BACK (COPY (LIST (QUOTE AWARE)
(CADR ACT)
(QUOTE LIST)))))
(SET AWARE:LIST (CONS UTILIZATION (EVAL AWARE:LIST)))
UTIL2)
COMPLEXITY:VECTOR (.6 .7 .5 .5 .1)
FAST:COMPLEX .153)
(PUTPROPS WRITE:PROGRAM IDEN (((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T)))
((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((Z@ (MATCH (QUOTE (WRITE A PROGRAM WHICH FRAG1))
LI))
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T))))
BEING T
IMPLICIT:ARGS (TASK:TYPE TASK:NAME FARGS)
EXPLICIT:ARGS (TASK)
WHAT (TUPLE WRITE A PROGRAM WHICH DOES (@ TASK))
HOW (TUPLE CREATE SPECIALIZED LISP CODE WHICH WILL DO (@ TASK))
WHY (TUPLE FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE WRITTEN TO DO
(@ TASK)
IN ORDER THAT THE TASK (@ TASK)
MIGHT BE COMPLETED; ALSO, EXAMINE SPEC:WHY)
WHEN ((T (COND ((MEMBER TASK ABLE:PUP:LIST)
-75)
(T 40))
(TUPLE BECAUSE A PRE:EXISTING ABILITY TO DO (@ TASK)
IMPLIES THAT WRITING A NEW PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
CONVERSELY, THE INABILITY TO DO (@ TASK)
ABDUCTIVELY ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
((MEMBER TASK WRITTEN:PROGRAMS:LIST)
-80
(QUOTE (BECAUSE WE ARE NOT AFTER MUCH EFFICIENCY, AND IF A PROGRAM ALREADY EXISTS,
THEN WE SHOULD USE IT)))
((MEMBER (TUPLE PUP IS ABOUT TO WRITE A PROGRAM TO DO (@ TASK))
AWARE:USER:LIST)
70
(QUOTE (BECAUSE WE GO BY THE OLD ENGLISH LEGAL RULE, THAT SILENCE SIGNIFIES APPROVAL)))
(T (COND (NEW:INFO:LIST -120)
(T 40))
(QUOTE (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE WRITING PROGRAMS ALSO:
BECAUSE IF NO NEW INFO IS PRESENT, THEN WE NEEDN'T FEEL GUILTY ABOUT
STARTING TO WRITE A PROGRAM))))
META:CODE (PROG (DONE PGM)
(SETQ PGM (VECTOR))
(SETQ UNDEFINED:SECTION:LIST (CONS (VECTOR (@ TASK:NAME)
TYPE OF (@ TASK))
UNDEFINED:SECTION:LIST))
LABEL4
(ECONOMY:DEMON)
(COND ((AND (GETP TASK:NAME BEING)
(NULL CODING:WARNING:LIST)
(NULL EXECUTABLE:INFO:LIST)
(NULL NEW:INFO:LIST)
(NULL UNDEFINED:SECTION:LIST))
(PUPRIN1 " NEAR END OF TASK -- ")
(PERMIT:USER:INTERRUPT)
(COND (DEFERRED:DECISION:LIST (SETQ DOING:PUP:LIST
(CONS (VECTOR DETAIL OF OUTPUTING)
DOING:PUP:LIST))
(SETQ CHOICE NIL)
(REINVESTIGATION:DEMON)))
(SETQ WRITTEN:PROGRAMS:LIST (CONS TASK WRITTEN:PROGRAMS:LIST))
(SETQ ABLE:PUP:LIST (CONS TASK ABLE:PUP:LIST))
(SETQ ABLE:USER:LIST (CONS TASK ABLE:USER:LIST))
(INTERSECTION GLOBAL:INITIALIZATION:LIST GLOBAL:INITIALIZATION:LIST)
(SUPPORT&DUMP TASK:NAME)
(RETURN T))
((NOT (MEMBER NIL (MAPCAR (APPEND USER:INTERRUPT:DEMONS CURRENT:DEMONS)
(QUOTE APPLY*))))
(CHOOSE:FROM (QUOTE ((OBTAIN:USABLE:INFORMATION (QUOTE PGM))
(USE:INFORMATION (QUOTE PGM))
(FILL:IN:UNDEFINED:SECTION (QUOTE PGM))
(CLARIFY:IMPROBABLE:SITUATION (QUOTE PGM))
(ADAPT:PRECONCEIVED:FUNCTION (QUOTE PGM))
(FIX:INCORRECT:PIECE (QUOTE PGM)))))
(GO LABEL4))
(T (RETURN NIL))))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WRITE A PROGRAM TO DO
(@ TASK)))
(VECTOR NAMED EXPRESSION (@ TASK)
(VECTOR TASK:NAME))
(VECTOR AWARE USER (VECTOR THE NAME OF THE PROGRAM TO DO (@ TASK)
IS
(@ TASK:NAME)))
(VECTOR TYPE OF (VECTOR (@ TASK)
HAS BEEN STUDIED)))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR THE PROGRAM (@ TASK:NAME)
TO DO (@ TASK)
IS COMPLETE)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATION:DEMON)
MAIN:EFFECTS (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1))))
AFFECTS (QUOTE ((OBTAIN:USABLE:INFORMATION POSSIBLE:CALLED)
(USE:INFORMATION POSSIBLE:CALLED)
(FILL:IN:UNDEFINED:SECTION POSSIBLE:CALLED)
(CLARIFY:IMPROBABLE:SITUATION POSSIBLE:CALLED)
(ADAPT:PRECONCEIVED:FUNCTION POSSIBLE:CALLED)))
COMPLEXITY:VECTOR ((PLUS .3 (TIMES .6 (DIMENSION1 TASK:TYPE)))
.9 .7 .5 .1)
FAST:COMPLEX .1698)
(MAPC (APPEND PUP6FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ NOLINKFNS T)
(SETQ #RPARS NIL)
(DWIM)
(PRIN1 "
DWIM DISABLED. TO GET AUTOMATIC EDITF FROM SOURCE, TYPE DWIM(T)
")
(CHANGESLICE 6)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(WIDEPAPER T)
(MAPC SET:OF:BEINGS SEMI:COMPILE)
(PUPRIN1 " MINI PUP FILE; USE FAD OR AD OR MAKEFILE ")
[DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS
(ADDTOVAR NLAMA VECTOR TUPLE STRUCTURE CSORT COMMENT CLASS)
(ADDTOVAR NLAML FORSOME)
]
(DECLARE: DONTCOPY
(FILEMAP (NIL (5223 69703 (@ 5235 . 5261) (A:BEING:ORDER 5265 . 5364) (A:BEING:WHEN 5368 . 5564) (AD 5568 . 5630)
(AD1 5634 . 6158) (ADD:BEING 6162 . 6904) (ADD:EFFECTS 6908 . 7078) (ADD:IDEN 7082 . 7232) (ALLSUBSTS 7236 . 7584)
(ANTI:RULE 7588 . 7648) (ANTIRULE 7652 . 7711) (ASSERTIONS 7715 . 7864) (ATOMP 7868 . 7921) (ATTENTION:DEMONS 7925
. 7961) (BREAK:PREADLIST 7965 . 8224) (CAAR:ORDER 8228 . 8304) (CAR:ORDER 8308 . 8651) (CHANGEB 8655 . 9535) (CHANGEP
9539 . 9807) (CHECK:COMMENTS 9811 . 9996) (CLASS 10000 . 10125) (COLON:BACK 10129 . 10313) (COLON:BREAK 10317 . 10777)
(COMMENT 10781 . 10937) (COMPATIBLE 10941 . 10978) (CSORT 10982 . 11083) (DEFERRAL:DEMON 11087 . 11180) (
DETERMINE:ALL:ARG2:VALUES 11184 . 11231) (DETERMINE:ALL:ARG3:VALUES 11235 . 11282) (DETERMINE:ALL:ARG:VALUES 11286
. 11332) (DETERMINE:ARG2:VALUE 11336 . 12486) (DETERMINE:ARG3:VALUE 12490 . 13404) (DETERMINE:ARG:VALUE 13408 . 14507)
(DIMENSION1 14511 . 14584) (DIMENSION2 14588 . 14662) (DIMENSION3 14666 . 14741) (DISK:DUMP 14745 . 14942) (DOT:PROD
14946 . 15123) (DUMMIES 15127 . 15284) (DUMP:BEING 15288 . 15594) (ECONOMY:DEMON 15598 . 16011) (ELIM:COMMON:HEAD
16015 . 16213) (ELIM:COMMON:TAIL 16217 . 16399) (ENTER 16403 . 17662) (EVALUATE:AFFECT 17666 . 18154) (EVEN:ALT 18158
. 18338) (FAD 18342 . 19457) (FAST 19461 . 19668) (FAST:A:BEING:ORDER 19672 . 19778) (FAST:BEING:COMPLEX 19782 . 20030)
(FAST:COMPILE 20034 . 20217) (FAST:PREAD 20221 . 20733) (FIND:AND:TAG 20737 . 21078) (FIND:INSIDE 21082 . 21478) (
FIRST:FEW 21482 . 21610) (FIRSTN 21614 . 21835) (FLATTEN 21839 . 21972) (FLOW:PRECEDED 21976 . 22225) (FOREVER 22229
. 22258) (FORGETFUL:USER:DEMON 22262 . 22396) (FORGOT:ANY 22400 . 22604) (FORSOME 22608 . 22905) (
FRINGE:OF:CONCIOUSNESS:DEMON 22909 . 22957) (GET:USAGE 22961 . 23323) (GETCODE 23327 . 26520) (HEAD 26524 . 26670)
(HIGHLY:STRUCTURED 26674 . 26762) (IDIOM:DEMON 26766 . 26797) (IMPROBABILITY:COMPLEX 26801 . 26892) (INCOMMENT 26896
. 27148) (INFER:INSIDE 27152 . 27206) (INFERENCE:DEMONS 27210 . 27246) (INITIALS 27250 . 27336) (INSERT:PRINT:STATEMENTS
27340 . 29957) (INSIDE 29961 . 30147) (INSTANTIATE 30151 . 30390) (INTUPLE 30394 . 30563) (INVECTOR 30567 . 30741)
(IRRELEVANT 30745 . 30799) (JPL 30803 . 30889) (LEARN:BY:EXAMPLE 30893 . 31152) (LIST:JOIN 31156 . 31619) (
LIST:TRANSLATE 31623 . 31808) (LISTFILES 31812 . 32257) (LOCATE:AFFECTED:AREA 32261 . 32401) (LOCATION:TRANSLATE 32405
. 32924) (LONG:NAME:DEMON 32928 . 33697) (LUMP:ASSERTIONS 33701 . 33980) (MAD 33984 . 34785) (MAIN:WORDS 34789 . 34852)
(MAKE:SPECIFIC 34856 . 34942) (MATCH 34946 . 35641) (MERGE:IN 35645 . 35915) (MERGE:IN2 35919 . 36053) (MINIMUM 36057
. 37341) (MINTERSECTION 37345 . 37534) (MOST:GENERAL 37538 . 37729) (MOVE:BEING 37733 . 38218) (MULT:INTERSECTION
38222 . 38400) (NEW:IDEN 38404 . 38792) (NEW:LEVEL 38796 . 40234) (NOT:YET:INITIALIZED 40238 . 40401) (NULLIFY 40405
. 40505) (NUMBER:SUBST 40509 . 40773) (ODD:ALT 40777 . 40933) (OPPOSITE 40937 . 41415) (OUTFORM 41419 . 41605) (OUTNIL
41609 . 41784) (OUTQUOTE 41788 . 42002) (OUTTUPLE 42006 . 42198) (OUTVECTOR 42202 . 42399) (PBT 42403 . 42597) (PBTV
42601 . 42845) (PERMIT:DETAILED:DECISION 42849 . 44273) (PERMIT:USER:INTERRUPT 44277 . 44633) (PLISTMATCH 44637 .
45350) (PLURAL 45354 . 45604) (POP:DEMONS 45608 . 45730) (PREAD 45734 . 45890) (PREDICT:AFFECT 45894 . 46109) (PREPL
46113 . 46587) (PRET 46591 . 46656) (PROCEDURE:INTERSECTION 46660 . 47106) (PROCEDURE:PULLOUT 47110 . 47504) (
PROCEDURE:SUBSET 47508 . 47643) (PROCESS:USER:INTERRUPT 47647 . 51501) (PROGRAM:WRITING:DEMONS 51505 . 51547) (
PSYCHOLOGY:DEMON 51551 . 51587) (PULLOUT 51591 . 51829) (PULLOUT1 51833 . 51988) (PUPP 51992 . 52173) (PUPRETTYPRINT
52177 . 52352) (PUPRIN1 52356 . 52519) (PUPRINT 52523 . 52686) (PUSH:DEMONS 52690 . 52918) (RANDOMSELECT 52922 . 53127)
(REINVESTIGATION:DEMON 53131 . 53329) (RELEVANT 53333 . 53379) (REMOVE:EFFECTS 53383 . 53559) (REMOVE:IDEN 53563 .
53722) (RFAST 53726 . 53832) (SELECT:STRUCTURE:TYPE 53836 . 54057) (SEMI:COMPILE 54061 . 56164) (SET:UP:EFFECTS:TABLE
56168 . 56513) (SET:UP:IDEN:TABLE 56517 . 56861) (SETDIFFERENCE 56865 . 57076) (SETINTERSECTION 57080 . 57143) (SETUNION
57147 . 57233) (SINGLETON 57237 . 57284) (SINGULAR 57288 . 57406) (SIZE 57410 . 57484) (SNAPSHOT 57488 . 57567) (
SPECIFICITY:CHECK:DEMON 57571 . 57704) (START 57708 . 60012) (STRUCTURE 60016 . 60072) (STRUCTURE:COMPATIBLE 60076
. 60459) (STRUCTURE:INDUCING:DEMON 60463 . 62431) (SUBALLEVELS 62435 . 62792) (SUBSTITUTE 62796 . 62916) (SWITCHFAST
62920 . 63131) (SWITCHFN 63135 . 63312) (TEMPORARILY 63316 . 63365) (TRACE:COMPILE 63369 . 65912) (TRUE:MINIMUM 65916
. 66590) (TRY:TO:SATISFY 66594 . 66734) (TUPLE 66738 . 66870) (UNGERUNDIFY 66874 . 67437) (USER:INTERRUPT:AT:ADAPTING
67441 . 67611) (USER:INTERRUPT:AT:CODING 67615 . 67762) (USER:INTERRUPT:AT:DEBUG 67766 . 67934) (USER:INTERRUPT:AT:END
67938 . 68169) (USER:INTERRUPT:AT:PHASES 68173 . 68565) (VECTOR 68569 . 68733) (VECTOR:AVERAGE 68737 . 69117) (
VECTOR:SUM 69121 . 69342) (WHEN:VALUE 69346 . 69669) (Z@ 69673 . 69700)))))
STOP